server

type Adapter interface {
	Add(client ClientWriter) error
	Remove(clientID identifiers.ClientID) error
	Broadcast(msg message.Message) error
	Metadata(clientID identifiers.ClientID) (string, bool)
	SetMetadata(clientID identifiers.ClientID, metadata string) bool
	Emit(clientID identifiers.ClientID, msg message.Message) error
	Clients() (map[identifiers.ClientID]string, error)
	Size() (int, error)
	Close() error
}

type AdapterFactory struct {
	NewAdapter func(room identifiers.RoomID) Adapter
	// contains filtered or unexported fields
}

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

type AuthType string

type ByteSerializer struct{}

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

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

type ClientConfig struct {
	BaseURL    string          `json:"baseUrl"`
	Nickname   string          `json:"nickname"`
	CallID     string          `json:"callId"`
	PeerID     string          `json:"peerId"`
	ICEServers []ICEAuthServer `json:"iceServers"`
	Network    NetworkType     `json:"network"`
}

type ClientWriter interface {
	ID() identifiers.ClientID
	Write(msg message.Message) error
	Metadata() string
	SetMetadata(metadata string)
}

type Config struct {
	BaseURL  string `yaml:"base_url"`
	BindHost string `yaml:"bind_host"`
	BindPort int    `yaml:"bind_port"`
	// When FS is non empty, it will be used as a root path to the resource files.
	FS         string           `yaml:"fs"`
	ICEServers []ICEServer      `yaml:"ice_servers"`
	TLS        TLSConfig        `yaml:"tls"`
	Store      StoreConfig      `yaml:"store"`
	Network    NetworkConfig    `yaml:"network"`
	Prometheus PrometheusConfig `yaml:"prometheus"`
}

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

type Deserializer interface {
	Deserialize([]byte) (message.Message, error)
}

type Doner interface {
	Done()
}

type Embed struct {
	Templates fs.FS
	Static    fs.FS
	Resources fs.FS
}

type ICEAuthServer struct {
	URLs       []string `json:"urls"`
	Username   string   `json:"username,omitempty"`
	Credential string   `json:"credential,omitempty"`
}

type ICEServer struct {
	URLs       []string `yaml:"urls"`
	AuthType   AuthType `yaml:"auth_type"`
	AuthSecret struct {
		Username string `yaml:"username"`
		Secret   string `yaml:"secret"`
	} `yaml:"auth_secret"`
}

type JSONMessage struct {
	Type    string `json:"type"`
	Payload string `json:"payload"`
}

type LocalTrack struct {
	*webrtc.TrackLocalStaticRTP
	// contains filtered or unexported fields
}

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

type MultiErrorHandler = multierr.MultiErr

type Mux struct {
	BaseURL string
	// contains filtered or unexported fields
}

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

type NetworkConfig struct {
	Type NetworkType      `yaml:"type"`
	SFU  NetworkConfigSFU `yaml:"sfu"`
}

type NetworkConfigSFU struct {
	Interfaces []string `yaml:"interfaces"`
	// JitterBuffer is disabled for now.
	JitterBuffer  bool            `yaml:"jitter_buffer"`
	Protocols     []string        `yaml:"protocols"`
	TCPBindAddr   string          `yaml:"tcp_bind_addr"`
	TCPListenPort int             `yaml:"tcp_listen_port"`
	Transport     TransportConfig `yaml:"transport"`
	UDP           struct {
		PortMin uint16 `yaml:"port_min"`
		PortMax uint16 `yaml:"port_max"`
	} `yaml:"udp"`
}

type NetworkType string

type NewAdapterFunc func(room identifiers.RoomID) Adapter

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

type NodeManagerParams struct {
	Log           logger.Logger
	RoomManager   *ChannelRoomManager
	TracksManager TracksManager
	ListenAddr    *net.UDPAddr
	Nodes         []*net.UDPAddr
}

type PageHandler func(
	w http.ResponseWriter,
	r *http.Request,
) (templateName string, data interface{}, err error)

type Params struct {
	TLSCertFile string
	TLSKeyFile  string
}

type PrometheusConfig struct {
	AccessToken string `yaml:"access_token"`
}

type ReadyMessage struct {
	PeerID string `json:"peerId"`
	Room   string `json:"room"`
}

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

type RedisConfig struct {
	Host   string `yaml:"host"`
	Port   int    `yaml:"port"`
	Prefix string `yaml:"prefix"`
}

type RemoteTrack struct {
	*webrtc.TrackRemote
	// contains filtered or unexported fields
}

type Renderer struct {
	Version string
	BaseURL string
	// contains filtered or unexported fields
}

type RoomEvent struct {
	RoomName identifiers.RoomID
	Type     RoomEventType
}

type RoomEventType int

type RoomManager interface {
	Enter(room identifiers.RoomID) (adapter Adapter, isNew bool)
	Exit(room identifiers.RoomID) (isRemoved bool)
}

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

type RoomManagerFactoryParams struct {
	AdapterFactory *AdapterFactory
	TracksManager  TracksManager
	Log            logger.Logger
}

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

type Serializer interface {
	Serialize(message.Message) ([]byte, error)
}

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

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

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

type StoreConfig struct {
	Type  StoreType   `yaml:"type"`
	Redis RedisConfig `yaml:"redis"`
}

type StoreType string

type TLSConfig struct {
	Cert string `yaml:"cert"`
	Key  string `yaml:"key"`
}

type Templates map[string]*template.Template

type TracksManager interface {
	Add(room identifiers.RoomID, transport transport.Transport) (<-chan pubsub.PubTrackEvent, error)
	Sub(params sfu.SubParams) error
	Unsub(params sfu.SubParams) error
}

type TransceiverRequest struct {
	CodecType webrtc.RTPCodecType
	Init      webrtc.RtpTransceiverInit
}

type TransportConfig struct {
	ListenAddr string `yaml:"listen_addr"`
	Nodes      []string
}

type WSCloser interface {
	Close(statusCode websocket.StatusCode, reason string) error
}

type WSReadWriter interface {
	WSReader
	WSWriter
	WSCloser
}

type WSReader interface {
	Read(ctx context.Context) (websocket.MessageType, []byte, error)
}

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

type WSWriter interface {
	Write(ctx context.Context, typ websocket.MessageType, msg []byte) error
}

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

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

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