websocket

type Action string

type Anonymous struct{}

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

type Channel[C, R, S any] struct {
	// contains filtered or unexported fields
}

type ChannelID string

type ChannelInfo struct {
	ID         ChannelID                 `json:"id"`
	Room       foundryhttp.URLScalarInfo `json:"room"`
	Private    bool                      `json:"private"`
	OwnedRooms bool                      `json:"owned_rooms"`
	Guard      auth.GuardName            `json:"guard,omitempty"`
	Provider   auth.ProviderName         `json:"provider,omitempty"`
	Presence   *contract.Schema          `json:"presence,omitempty"`
	Replay     ReplayConfig              `json:"replay,omitzero"`
	Events     []EventInfo               `json:"events"`
}

type ChannelSnapshot struct {
	ID                                                                      ChannelID
	Subscriptions                                                           int
	Incoming, Accepted, Completed, Failures, Published, Delivered, Replayed uint64
}

type ClientDescription struct {
	Protocol ProtocolInfo  `json:"protocol"`
	Limits   ClientLimits  `json:"limits"`
	Channels []ChannelInfo `json:"channels"`
}

type ClientLimits struct {
	Subscriptions         int   `json:"subscriptions"`
	FrameBytes            int   `json:"frame_bytes"`
	PresenceMembers       int   `json:"presence_members"`
	MemberBytes           int   `json:"member_bytes"`
	DeduplicationEntries  int   `json:"deduplication_entries"`
	OperationMilliseconds int64 `json:"operation_ms"`
	// InboundQueue bounds a client's in-flight operations; MessageRate is the
	// per-connection frame budget. Generated clients respect both.
	InboundQueue int                 `json:"inbound_queue"`
	MessageRate  ClientRate          `json:"message_rate"`
	Payload      contract.JSONLimits `json:"payload"`
}

type ClientRate struct {
	Requests           uint32 `json:"requests"`
	WindowMilliseconds int64  `json:"window_ms"`
}

type ClusterBackend interface {
	pubsub.Backend
	WebSocketCheck(context.Context, ClusterKey) error
	WebSocketOpen(context.Context, ClusterKey, InstanceID, ConnectionID) error
	WebSocketTouch(context.Context, ClusterKey, InstanceID, ConnectionID) error
	WebSocketJoin(context.Context, ClusterKey, InstanceID, ConnectionID, ClusterMembership) (PresenceSnapshot, error)
	WebSocketLeave(context.Context, ClusterKey, InstanceID, ConnectionID, Scope) error
	WebSocketClose(context.Context, ClusterKey, InstanceID, ConnectionID) error
	WebSocketMembers(context.Context, ClusterKey, Scope) (PresenceSnapshot, error)
	WebSocketAppend(context.Context, ClusterKey, ChannelID, ReplayConfig, []byte) error
	WebSocketHistory(context.Context, ClusterKey, ChannelID, ReplayConfig) ([][]byte, error)
}

type ClusterConfig struct {
	Namespace                keyspace.Namespace
	MaxConnections           int
	MaxConnectionsPerSubject int
	ConnectionTTL            time.Duration
	OperationTimeout         time.Duration
	Buffer                   pubsub.Limits
	// RetainConnectionsOnGap keeps local sockets open across a lost fan-out
	// stream; events published during the gap are then missed silently. The
	// default closes them with a retryable status so clients reconnect and
	// request replay.
	RetainConnectionsOnGap bool
	// ExcludeRemoteConnections lets ExceptConnection name a connection hosted
	// by another instance by carrying the exclusion in the fan-out envelope.
	// Instances before this field reject such envelopes, so enable it only
	// once every instance in the namespace runs a release that has it.
	// Excluding a connection of this instance (RelayToOthers) never needs it.
	ExcludeRemoteConnections bool
}

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

type ClusterLimits struct {
	Connections           int           `json:"connections"`
	ConnectionsPerSubject int           `json:"connections_per_subject"`
	Subscriptions         int           `json:"subscriptions"`
	PresenceMembers       int           `json:"presence_members"`
	MemberBytes           int           `json:"member_bytes"`
	FrameBytes            int           `json:"frame_bytes"`
	ConnectionTTL         time.Duration `json:"connection_ttl"`
	Retention             time.Duration `json:"retention"`
}

type ClusterMembership struct {
	Scope    Scope
	Subject  MemberID
	Presence bool
	Data     json.RawMessage
}

type Code string

type Config struct {
	MaxPresenceScopes int
	MaxConnections    int
	MaxSubscriptions  int
	MaxFrameBytes     int
	// InboundQueue bounds frames read but not yet processed. Generated clients
	// limit their in-flight operations to it; overflowing it closes the socket.
	InboundQueue int
	// OutboundQueue bounds queued frames per connection. MaxQueuedBytes bounds
	// their actual bytes, including inbound frames and pending-admission
	// buffers; MaxTotalQueuedBytes bounds all connections together. Exceeding
	// either disconnects the slow connection instead of blocking publishers.
	OutboundQueue       int
	MaxQueuedBytes      int
	MaxTotalQueuedBytes int64
	// MaxOperations bounds concurrent trusted publication, presence and
	// disconnect operations. Callers wait briefly, then receive fault.Overloaded.
	MaxOperations            int
	MaxPresenceMembers       int
	MaxMemberBytes           int
	OperationTimeout         time.Duration
	WriteTimeout             time.Duration
	HeartbeatInterval        time.Duration
	PongTimeout              time.Duration
	AuthRefreshInterval      time.Duration
	DrainTimeout             time.Duration
	MaxConnectionsPerIP      int
	MaxConnectionsPerSubject int
	DeduplicationEntries     int
	MessageRate              ratelimit.Limit
	Payload                  contract.JSONLimits
	// AdditionalOrigins are exact HTTP(S) origins, never wildcard patterns.
	// Same-origin is accepted after trusted-proxy handling. Originless clients
	// must be explicitly allowed; serialized opaque/null origins never are.
	AdditionalOrigins []foundryhttp.Origin `config:",json"`
	AllowOriginless   bool
}

type Connection struct{}

type ConnectionID = model.ID[Connection]

type ConnectionName string

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

type Diagnostics struct {
	Runtime                                                         Snapshot
	QueuedFrames, QueuedBytes                                       int
	HeartbeatFailures, RateRejected, Revocations, ForcedDisconnects uint64
	// CleanupFailures counts cluster membership releases or stream closes that
	// failed; leases expire by TTL and presence is reconciled.
	CleanupFailures uint64
	Channels        []ChannelSnapshot
}

type Direction string

type EventID string

type EventInfo struct {
	ID                      EventID         `json:"id"`
	Direction               Direction       `json:"direction"`
	Dynamic                 bool            `json:"dynamic"`
	AcceptedAcknowledgement bool            `json:"accepted_acknowledgement"`
	Payload                 contract.Schema `json:"payload,omitzero"`
}

type EventRegistration[C any] struct {
	// contains filtered or unexported fields
}

type Hooks[R, S any] struct {
	Joined func(context.Context, MessageContext[R, S]) error
	Left   func(context.Context, LeaveContext[R]) error
}

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

type Incoming[C, R, S, P any] struct {
	// contains filtered or unexported fields
}

type Instance struct{}

type InstanceID = model.ID[Instance]

type LeaveContext[R any] struct {
	Publisher  *Hub
	Connection ConnectionID
	Target     Target[R]
	Subject    SubjectReference
}

type Member[D any] struct {
	ID          MemberID
	Data        D
	Connections int
}

type MemberFrame struct {
	ID          MemberID        `json:"id"`
	Data        json.RawMessage `json:"data"`
	Connections int             `json:"connections"`
}

type MemberID string

type MessageContext[R, S any] struct {
	Publisher  *Hub
	Connection ConnectionID
	Target     Target[R]
	Subject    S
}

type MessageID = model.ID[Publication]

type NamedConnection struct {
	Name  ConnectionName
	Value *BackendConnection
}

type Option func(*options) error

type Outgoing[C, P any] struct {
	// contains filtered or unexported fields
}

type PresenceChannel[C, R, S, D any] struct {
	// contains filtered or unexported fields
}

type PresenceSnapshot struct {
	Revision uint64        `json:"revision"`
	Members  []MemberFrame `json:"members"`
}

type ProtocolActions struct {
	Subscribe   Action `json:"subscribe"`
	Unsubscribe Action `json:"unsubscribe"`
	Message     Action `json:"message"`
}

type ProtocolInfo struct {
	Version           int               `json:"version"`
	Subprotocol       string            `json:"subprotocol"`
	TicketPrefix      string            `json:"ticket_subprotocol_prefix"`
	MaxRoomBytes      int               `json:"max_room_bytes"`
	MaxReplayMessages int               `json:"max_replay_messages"`
	Actions           ProtocolActions   `json:"actions"`
	Responses         ProtocolResponses `json:"responses"`
	Codes             []Code            `json:"codes"`
}

type ProtocolResponses struct {
	Subscribed      ResponseType `json:"subscribed"`
	Unsubscribed    ResponseType `json:"unsubscribed"`
	Acknowledged    ResponseType `json:"acknowledged"`
	Accepted        ResponseType `json:"accepted"`
	Error           ResponseType `json:"error"`
	Event           ResponseType `json:"event"`
	PresenceJoined  ResponseType `json:"presence_joined"`
	PresenceLeft    ResponseType `json:"presence_left"`
	PresenceUpdated ResponseType `json:"presence_updated"`
}

type Publication struct{}

type PublishOption func(*publishOptions)

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

type PublisherSource interface {
	// contains filtered or unexported methods
}

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

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

type ReplayConfig struct {
	Messages int           `json:"messages"`
	Bytes    int           `json:"bytes"`
	TTL      time.Duration `json:"ttl"`
}

type Request struct {
	Version int             `json:"v"`
	Action  Action          `json:"action"`
	ID      RequestID       `json:"id"`
	Channel ChannelID       `json:"channel"`
	Room    *string         `json:"room,omitempty"`
	Event   EventID         `json:"event,omitempty"`
	Payload json.RawMessage `json:"payload,omitempty"`
	Replay  *int            `json:"replay,omitempty"`
}

type RequestID string

type Response struct {
	Version   int             `json:"v"`
	Type      ResponseType    `json:"type"`
	ID        RequestID       `json:"id,omitempty"`
	Channel   ChannelID       `json:"channel,omitempty"`
	Room      *string         `json:"room,omitempty"`
	Event     EventID         `json:"event,omitempty"`
	MessageID MessageID       `json:"message_id,omitzero"`
	Payload   json.RawMessage `json:"payload,omitempty"`
	Code      Code            `json:"code,omitempty"`
	Members   []MemberFrame   `json:"members,omitempty"`
	Member    *MemberFrame    `json:"member,omitempty"`
	Replayed  bool            `json:"replayed,omitempty"`
}

type ResponseType string

type Rooms[R any] struct {
	// contains filtered or unexported fields
}

type Scope struct {
	Channel ChannelID `json:"channel"`
	Room    string    `json:"room"`
	HasRoom bool      `json:"has_room"`
}

type ServerConfig struct {
	HTTP       foundryhttp.ServerConfig
	Path       string
	Middleware []foundryhttp.Middleware
}

type Snapshot struct {
	Distributed, Degraded                                       bool
	Streaming                                                   bool
	BackgroundTasks                                             int
	Stopping                                                    bool
	Connections                                                 int
	Subscriptions                                               int
	ActiveOperations                                            int
	QueuedBytes                                                 int64
	Accepted, Rejected, Publications, SlowConsumers, Failures   uint64
	Gaps, Resubscriptions, DroppedEnvelopes, OperationOverloads uint64
}

type SubjectReference struct {
	Guard    auth.GuardName
	Provider auth.ProviderName
	Identity model.Identity
}

type Target[R any] struct{ Room value.Optional[R] }

type TicketRedeemer interface {
	TicketSource() auth.CredentialName
	RedeemTicket(context.Context, secret.String) (value.Optional[auth.BoundCredential], error)
}