edge

type Addr struct {
	MsgCh MsgChannel
}

type BaseSdkChannel struct {
	channel.SenderContext
	// contains filtered or unexported fields
}

type ClientConfig struct {
	Protocol string
	Hostname ZitiAddress
	Port     int
}

type CloseWriter interface {
	CloseWrite() error
}

type Conn interface {
	ServiceConn
	Identifiable
	GetRouterId() string
	GetState() string
	CompleteAcceptSuccess() error
	CompleteAcceptFailed(err error)
}

type ConnMux[T any] interface {
	// Add registers a message handler for a specific connection.
	// The sink's ID() method determines which connection ID it handles.
	// Returns an error if the connection ID is already registered or if
	// registration fails for any other reason.
	//
	// Example:
	//   conn := &edgeXgressConn{connId: 12345, ...}
	//   err := mux.Add(conn)
	Add(sink MsgSink[T]) error

	// Remove unregisters the specified message handler.
	// This removes the connection from the multiplexer's routing table.
	// The method is idempotent - removing a non-existent sink is not an error.
	//
	// Example:
	//   mux.Remove(conn)
	Remove(sink MsgSink[T])

	// RemoveByConnId removes a connection by its ID from the multiplexer.
	// This is a convenience method that removes the connection without
	// requiring a reference to the original MsgSink.
	// The method is idempotent - removing a non-existent connection ID is not an error.
	//
	// Parameters:
	//   connId - the connection ID to remove
	//
	// Example:
	//   mux.RemoveByConnId(12345)
	RemoveByConnId(connId uint32)

	// Close shuts down the multiplexer and all managed connections.
	// After calling Close, the multiplexer should not accept new connections
	// or route any more messages. All registered message sinks will be notified
	// of the closure.
	//
	// This method should be called when the underlying channel is being closed
	// to ensure proper cleanup of all multiplexed connections.
	Close()

	// GetActiveConnIds returns a slice of all active connection IDs.
	// This method provides visibility into which connections are currently
	// being managed by the multiplexer.
	//
	// Returns:
	//   []uint32 - slice of active connection IDs, may be empty if no connections exist
	//
	// Example:
	//   connIds := mux.GetActiveConnIds()
	//   fmt.Printf("Active connections: %v\n", connIds)
	GetActiveConnIds() []uint32

	// HasConn checks if a specific connection ID is currently active.
	// This is useful for validation before attempting operations on a connection.
	//
	// Parameters:
	//   connId - the connection ID to check
	//
	// Returns:
	//   bool - true if the connection exists, false otherwise
	//
	// Example:
	//   if mux.HasConn(12345) {
	//       // connection exists, safe to send messages
	//   }
	HasConn(connId uint32) bool

	// GetConnCount returns the number of active connections.
	// This provides a quick way to check multiplexer load without
	// allocating a slice of connection IDs.
	//
	// Returns:
	//   int - number of active connections
	//
	// Example:
	//   count := mux.GetConnCount()
	//   if count > maxConnections {
	//       // handle overload condition
	//   }
	GetConnCount() int

	// GetSinks returns a snapshot of all currently active message sinks managed by this multiplexer.
	// This method provides access to the complete set of active connections and their associated
	// message handlers, indexed by their connection IDs.
	//
	// The returned map is a snapshot taken at the time of the call and will not reflect
	// subsequent additions or removals of connections. This method is useful for:
	//   - Administrative operations that need to inspect all active connections
	//   - Debugging and monitoring tools
	//   - Broadcasting operations across all connections
	//   - Connection lifecycle management and cleanup
	//
	// Returns:
	//   map[uint32]MsgSink[T] - a map of connection IDs to their corresponding message sinks
	//
	// Thread Safety: This method is safe for concurrent use.
	//
	// Example:
	//   sinks := mux.GetSinks()
	//   for connId, sink := range sinks {
	//       fmt.Printf("Connection %d: %v\n", connId, sink.GetData())
	//   }
	GetSinks() map[uint32]MsgSink[T]

	// GetNextId generates the next available connection ID for creating new connections.
	// This method ensures that connection IDs are unique within the multiplexer's scope
	// and handles ID allocation automatically. The implementation may use sequential
	// numbering, random generation, or other strategies to avoid collisions.
	//
	// The returned ID is guaranteed to be unique among currently active connections
	// and can be safely used for creating new MsgSink instances.
	//
	// Returns:
	//   uint32 - a unique connection ID that can be used for a new connection
	//
	// Example:
	//   connId := mux.GetNextId()
	//   conn := &myConnection{id: connId}
	//   mux.Add(conn)
	GetNextId() uint32

	// TypedReceiveHandler is an embedded interface
	//
	// TypedReceiveHandler provides typed message handling capabilities for the multiplexer.
	// This allows the ConnMux to be registered as a message handler with the underlying
	// channel infrastructure, enabling automatic message routing based on message types.
	//
	// The embedded interface typically includes methods like:
	//   - ContentType() int32 - returns the message content type this handler processes
	//   - HandleReceive(msg *channel.Message, ch channel.Channel) - processes typed messages
	//
	// This integration allows the ConnMux to participate in the channel's message
	// dispatch system while maintaining its connection multiplexing functionality.
	channel.TypedReceiveHandler

	// CloseHandler is an embedded interface
	//
	// CloseHandler provides automatic cleanup capabilities when the underlying channel closes.
	// This ensures that all multiplexed connections are properly notified and cleaned up
	// when the physical channel connection is terminated.
	//
	// The embedded interface typically includes:
	//   - HandleClose(ch channel.Channel) - called when the channel is closing
	//
	// When the channel closes, the ConnMux should:
	//   - Notify all registered MsgSinks via their HandleMuxClose() method
	//   - Clean up internal routing tables and connection state
	//   - Release any held resources
	//
	// This automatic integration ensures graceful shutdown of all multiplexed
	// connections without requiring manual cleanup by the application.
	channel.CloseHandler
}

type ConnMuxImpl[T any] struct {
	// contains filtered or unexported fields
}

type ConnOptions interface {
	GetConnectTimeout() time.Duration
}

type ConnType byte

type CryptoMethod byte

type DialOptions struct {
	ConnectTimeout  time.Duration
	Identity        string
	CallerId        string
	AppData         []byte
	StickinessToken []byte
	SdkFlowControl  bool
}

type DialResult struct {
	ConnId    uint32
	NewConnId uint32
	Success   bool
	Message   string
}

type DialSdkChannel struct {
	BaseSdkChannel
	// contains filtered or unexported fields
}

type DomainName string

type Identifiable interface {
	Id() uint32
}

type InspectResult struct {
	ConnId uint32
	Type   ConnType
	Detail string
}

type InterceptDialOptions struct {
	ConnectTimeoutSeconds *int
	Identity              *string
}

type InterceptV1Config struct {
	Addresses   []ZitiAddress
	PortRanges  []*PortRange
	Protocols   []string
	SourceIp    *string
	DialOptions *InterceptDialOptions `json:"dialOptions"`
	Service     *rest_model.ServiceDetail
}

type ListenOptions struct {
	Cost                  uint16
	Precedence            Precedence
	ConnectTimeout        time.Duration
	MaxTerminators        int
	Identity              string
	IdentitySecret        string
	BindUsingEdgeIdentity bool
	ManualStart           bool
	SdkFlowControl        bool
	ListenerId            string
	KeyPair               *kx.KeyPair
	// contains filtered or unexported fields
}

type Listener interface {
	net.Listener
	Identifiable
	AcceptEdge() (Conn, error)
	IsClosed() bool
	UpdateCost(cost uint16) error
	UpdatePrecedence(precedence Precedence) error
	UpdateCostAndPrecedence(cost uint16, precedence Precedence) error
	SendHealthEvent(pass bool) error
}

type ListenerEvent struct {
	EventType ListenerEventType
}

type ListenerEventType int

type MsgChannel struct {
	SdkChannel
	// contains filtered or unexported fields
}

type MsgEvent struct {
	ConnId  uint32
	Seq     uint32
	MsgUUID []byte
	Msg     *channel.Message
}

type MsgSink[T any] interface {
	// Id returns the unique connection ID that this sink handles.
	// This ID is used by the ConnMux to route messages to the correct sink.
	// The ID must remain constant for the lifetime of the sink.
	//
	// Returns:
	//   uint32 - the connection ID for this message sink
	//
	// Example:
	//   connId := sink.Id()
	//   // Use connId for routing decisions
	Id() uint32

	// Accept processes an incoming message for this connection.
	// The message is guaranteed to be intended for this sink's connection ID.
	// The sink should handle the message appropriately based on its type and content.
	//
	// Parameters:
	//   msg - the incoming message to process
	//
	// Example:
	//   func (s *myMsgSink) Accept(msg *channel.Message) {
	//       switch msg.ContentType {
	//       case edge.ContentTypeData:
	//           s.handleData(msg)
	//       case edge.ContentTypeStateClosed:
	//           s.handleClose(msg)
	//       }
	//   }
	Accept(msg *channel.Message)

	// HandleMuxClose is called when the underlying multiplexer is closing.
	// This gives the sink an opportunity to perform cleanup operations
	// and notify any dependent components that the connection is being terminated.
	//
	// The sink should:
	//   - Release any held resources
	//   - Notify dependent components of the closure
	//   - Complete any pending operations gracefully
	//
	// Returns:
	//   error - any error encountered during cleanup, nil if successful
	//
	// Example:
	//   func (s *myMsgSink) HandleMuxClose() error {
	//       s.cleanup()
	//       return s.conn.Close()
	//   }
	HandleMuxClose() error

	// GetData retrieves arbitrary context data associated with this connection.
	// This allows implementing code to store and retrieve connection-specific
	// context, state, or metadata that may be needed across different operations.
	//
	// The data is connection-scoped and persists for the lifetime of the MsgSink.
	// Returns nil if no data has been set.
	//
	// Returns:
	//  T - the stored context data, or nil if none exists
	//
	// Example:
	//   userData := sink.GetData()
	//   if edgeCtx, ok := userData.(*EdgeConnContext); ok {
	//       // Use context
	//   }
	GetData() T

	// SetData stores arbitrary context data associated with this connection.
	// This allows implementing code to attach connection-specific context,
	// state, or metadata that can be retrieved later during the connection's lifetime.
	//
	// The data should be treated as connection-scoped and will be available
	// until the connection is closed or the data is overwritten.
	//
	// Parameters:
	//   data - arbitrary context data to associate with this connection
	//
	// Example:
	//   authCtx := &AuthContext{UserID: "user123", Permissions: perms}
	//   sink.SetData(authCtx)
	//
	//   // Later retrieve it
	//   if ctx := sink.GetData(); ctx != nil {
	//       edgeCtx := ctx.(*EdgeConnContext)
	//       // Use context
	//   }
	SetData(data T)
}

type PortRange struct {
	Low  uint16
	High uint16
}

type Precedence byte

type RouterClient interface {
	Connect(service *rest_model.ServiceDetail, session *rest_model.SessionDetail, options *DialOptions, envF func() xgress.Env) (Conn, error)
	Listen(service *rest_model.ServiceDetail, session *rest_model.SessionDetail, options *ListenOptions, envF func() xgress.Env) (Listener, error)

	//UpdateToken will attempt to send token updates to the connected router. A success/failure response is expected
	//within the timeout period.
	UpdateToken(token []byte, timeout time.Duration) error
}

type RouterConn interface {
	channel.BindHandler
	io.Closer
	RouterClient
	IsClosed() bool
	Key() string
	GetRouterName() string
	GetBoolHeader(key int32) bool
}

type SdkChannel interface {
	InitChannel(channel.MultiChannel)
	GetChannel() channel.Channel
	GetDefaultSender() channel.Sender
	GetControlSender() channel.Sender
}

type ServiceConn interface {
	net.Conn
	CloseWriter
	IsClosed() bool
	GetAppData() []byte
	SourceIdentifier() string
	TraceRoute(hops uint32, timeout time.Duration) (*TraceRouteResult, error)
	GetCircuitId() string
	GetStickinessToken() []byte
}

type SessionListener interface {
	Listener
	GetCurrentSession() *rest_model.SessionDetail
	SetConnectionChangeHandler(func(conn []Listener))
	SetErrorEventHandler(func(error))
	GetErrorEventHandler() func(error)
}

type SingleSdkChannel struct {
	// contains filtered or unexported fields
}

type TraceRouteResult struct {
	Hops    uint32
	Time    time.Duration
	HopType string
	HopId   string
	Error   string
}

type UnderlayHandlerSdkChannel interface {
	SdkChannel
	channel.UnderlayHandler
}

type ZitiAddress struct {
	// contains filtered or unexported fields
}