sio

type Binary []byte

type BroadcastOperator = adapter.BroadcastOperator

type ClientSocket interface {
	Socket
	ClientSocketEvents

	// Whether the socket will try to reconnect when its Client (manager) connects or reconnects.
	Active() bool

	// Connect the socket.
	Connect()

	// Disconnect the socket (a DISCONNECT packet will be sent).
	Disconnect()

	// Retrieves the Manager.
	Manager() *Manager

	// Setting the authentication data is optional and if used, it must be a JSON object (struct or map).
	// Non-JSON-object authentication data will not accepted, and panic will occur.
	SetAuth(v any)
	// Get the authentication data that was set by `SetAuth`.
	// As you might have guessed, returns nil if authentication data was not set before.
	Auth() (v any)

	Volatile() Emitter
}

type ClientSocketConfig struct {
	// Authentication data.
	//
	// This can also be set/overridden using Socket.SetAuth method.
	Auth any

	// The maximum number of retries for the packet to be sent.
	// Above the limit, the packet will be discarded.
	//
	// Using `Infinity` means the delivery guarantee is
	// "at-least-once" (instead of "at-most-once" by default),
	// but a smaller value like 10 should be sufficient in practice.
	Retries int

	// The default timeout used when waiting for an acknowledgement.
	AckTimeout time.Duration
}

type ClientSocketConnectErrorFunc func(err any)

type ClientSocketConnectFunc func()

type ClientSocketDisconnectFunc func(reason Reason)

type ClientSocketEvents interface {
	OnConnect(f ClientSocketConnectFunc)

	OnceConnect(f ClientSocketConnectFunc)

	OffConnect(f ...ClientSocketConnectFunc)

	OnConnectError(f ClientSocketConnectErrorFunc)

	OnceConnectError(f ClientSocketConnectErrorFunc)

	OffConnectError(f ...ClientSocketConnectErrorFunc)

	OnDisconnect(f ClientSocketDisconnectFunc)

	OnceDisconnect(f ClientSocketDisconnectFunc)

	OffDisconnect(f ...ClientSocketDisconnectFunc)
}

type Debugger = eio.Debugger

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

type Handshake struct {
	// Date of creation
	Time time.Time

	// Authentication data
	Auth json.RawMessage
}

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

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

type ManagerCloseFunc func(reason Reason, err error)

type ManagerConfig struct {
	// For custom parsers
	ParserCreator parser.Creator

	// Configuration for the Engine.IO.
	EIO eio.ClientConfig

	// Should we disallow reconnections?
	// Default: false (allow reconnections)
	NoReconnection bool

	// How many reconnection attempts should we try?
	// Default: 0 (Infinite)
	ReconnectionAttempts uint32

	// The time delay between reconnection attempts.
	// Default: 1 second
	ReconnectionDelay *time.Duration

	// The max time delay between reconnection attempts.
	// Default: 5 seconds
	ReconnectionDelayMax *time.Duration

	// Used in the exponential backoff jitter when reconnecting.
	// This value is required to be between 0 and 1
	//
	// Default: 0.5
	RandomizationFactor *float32

	// For debugging purposes. Leave it nil if it is of no use.
	//
	// This only applies to Socket.IO. For Engine.IO, use EIO.Debugger.
	Debugger Debugger
}

type ManagerErrorFunc func(err error)

type ManagerOpenFunc func()

type ManagerPingFunc func()

type ManagerReconnectAttemptFunc func(attempt uint32)

type ManagerReconnectErrorFunc func(err error)

type ManagerReconnectFailedFunc func()

type ManagerReconnectFunc func(attempt uint32)

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

type NamespaceConnectionFunc func(socket ServerSocket)

type NspMiddlewareFunc func(socket ServerSocket, handshake *Handshake) any

type Reason = eio.Reason

type Room = adapter.Room

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

type ServerAnyConnectionFunc func(namespace string, socket ServerSocket)

type ServerConfig struct {
	// For custom parsers
	ParserCreator parser.Creator
	// For custom adapters
	AdapterCreator adapter.Creator

	// Engine.IO configuration
	EIO eio.ServerConfig

	// Duration to wait before a client without namespace is closed.
	//
	// Default: 45 seconds
	ConnectTimeout time.Duration

	// In order for a client to make a connection to a namespace,
	// the namespace must be created on server via `Server.of`.
	//
	// This option permits the client to create the namespace if it is not already created on server.
	// If this option is disabled, only namespaces created on the server can be connected.
	//
	// Default: false
	AcceptAnyNamespace bool

	ServerConnectionStateRecovery ServerConnectionStateRecovery

	// For debugging purposes. Leave it nil if it is of no use.
	//
	// This only applies to Socket.IO. For Engine.IO, use EIO.Debugger.
	Debugger Debugger
}

type ServerConnectionStateRecovery struct {
	// Enable connection state recovery
	//
	// Default: false
	Enabled bool

	// The backup duration of the sessions and the packets
	//
	// Default: 2 minutes
	MaxDisconnectionDuration time.Duration

	// Whether to execute middlewares upon successful connection state recovery.
	//
	// Default: false
	UseMiddlewares bool
}

type ServerNewNamespaceFunc func(namespace *Namespace)

type ServerSocket interface {
	Socket
	ServerSocketEvents

	// Retrieves the underlying Server.
	Server() *Server

	// Retrieves the Namespace this socket is connected to.
	Namespace() *Namespace

	// Join room(s)
	Join(room ...Room)
	// Leave a room
	Leave(room Room)
	// Get a set of all rooms socket was joined to.
	Rooms() mapset.Set[Room]

	// Register a middleware for events.
	//
	// Function signature must be same as with On and Once:
	// func(eventName string, v ...any) error
	Use(f any)

	// Sets a modifier for a subsequent event emission that the event
	// will only be broadcast to clients that have joined the given room.
	//
	// To emit to multiple rooms, you can call To several times.
	To(room ...Room) *BroadcastOperator

	// Alias of To(...)
	In(room ...Room) *BroadcastOperator

	// Sets a modifier for a subsequent event emission that the event
	// will only be broadcast to clients that have not joined the given rooms.
	Except(room ...Room) *BroadcastOperator

	// Sets a modifier for a subsequent event emission that
	// the event data will only be broadcast to the current node.
	Local() *BroadcastOperator

	// Sets a modifier for a subsequent event emission that
	// the event data will only be broadcast to every sockets but the sender.
	Broadcast() *BroadcastOperator

	// Disconnect from namespace.
	//
	// If `close` is true, all namespaces are going to be disconnected (a DISCONNECT packet will be sent),
	// and the underlying Engine.IO connection will be terminated.
	//
	// If `close` is false, only the current namespace will be disconnected (a DISCONNECT packet will be sent),
	// and the underlying Engine.IO connection will be kept open.
	Disconnect(close bool)
}

type ServerSocketDisconnectFunc func(reason Reason)

type ServerSocketDisconnectingFunc func(reason Reason)

type ServerSocketErrorFunc func(err error)

type ServerSocketEvents interface {
	OnError(f ServerSocketErrorFunc)

	OnceError(f ServerSocketErrorFunc)

	OffError(f ...ServerSocketErrorFunc)

	OnDisconnecting(f ServerSocketDisconnectingFunc)

	OnceDisconnecting(f ServerSocketDisconnectingFunc)

	OffDisconnecting(f ...ServerSocketDisconnectingFunc)

	OnDisconnect(f ServerSocketDisconnectFunc)

	OnceDisconnect(f ServerSocketDisconnectFunc)

	OffDisconnect(f ...ServerSocketDisconnectFunc)
}

type Socket interface {
	// Socket ID. For client socket, this may return an empty string if the client hasn't connected yet.
	ID() SocketID

	// Is the socket (currently) connected?
	Connected() bool

	// Whether the connection state was recovered after a
	// temporary disconnection. In that case, any missed packets
	// will be transmitted, the data attribute
	// and the rooms will be restored.
	Recovered() bool

	// Emit a message.
	// If you want to emit a binary data, use sio.Binary instead of []byte.
	Emit(eventName string, v ...any)

	// Return an emitter with timeout set.
	Timeout(timeout time.Duration) Emitter

	// Register an event handler.
	OnEvent(eventName string, handler any)

	// Register a one-time event handler.
	// The handler will run once and will be removed afterwards.
	OnceEvent(eventName string, handler any)

	// Remove an event handler.
	//
	// If you want to remove all handlers of a particular event,
	// provide the eventName and leave the handler nil.
	//
	// Otherwise, provide both the eventName and handler arguments.
	OffEvent(eventName string, handler ...any)

	// Remove all event handlers.
	// Including special event handlers (connect, disconnect, disconnecting, etc.).
	OffAll()
}

type SocketID = adapter.SocketID