sip

type ActiveCalls struct {
	Inbound   int
	Outbound  int
	SampleIDs []string
}

type AuthInfo struct {
	Result        AuthResult
	ProjectID     string
	TrunkID       string
	Auth          InboundAuth
	ProviderInfo  *livekit.ProviderInfo
	Observability *rpc.SIPCallObservability
}

type AuthResult int

type CallDispatch struct {
	Result              DispatchResult
	Room                RoomConfig
	ProjectID           string
	TrunkID             string
	DispatchRuleID      string
	Headers             map[string]string
	HeadersToAttributes map[string]string
	IncludeHeaders      livekit.SIPHeaderOptions
	AttributesToHeaders map[string]string
	EnabledFeatures     []livekit.SIPFeature
	FeatureFlags        map[string]string
	RingingTimeout      time.Duration
	MaxCallDuration     time.Duration
	MediaConfig         *livekit.SIPMediaConfig
}

type CallIdentifier struct {
	TraceID   traceid.ID
	ProjectID string
	CallID    string
	SipCallID string
}

type CallInfo struct {
	TrunkID string
	Call    *rpc.SIPCall
	Pin     string
	NoPin   bool
}

type CallInterface interface {
	EndCall(ctx context.Context, headers map[string]string) error
}

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

type CallStatus int

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

type ClientOption func(c *Client)

type DispatchResult int

type EndCall struct {
	Report  error      // reported to LiveKit analytics
	Status  CallStatus // TODO: legacy
	Term    stats.Termination
	Reason  livekit.DisconnectReason // disconnect reason for LiveKit participant
	Headers map[string]string        // extra headers to send to SIP peer
}

type GetRoomFunc func(log logger.Logger, st *RoomStats) RoomInterface

type GetSipClientFunc func(ua *sipgo.UserAgent, options ...sipgo.ClientOption) (SIPClient, error)

type GetStateHandler func(projectID string, obs *rpc.SIPCallObservability, initial *livekit.SIPCallInfo) StateHandler

type Handler interface {
	GetAuthCredentials(ctx context.Context, call *rpc.SIPCall) (AuthInfo, error)
	DispatchCall(ctx context.Context, info *CallInfo) CallDispatch
	GetMediaProcessor(features []livekit.SIPFeature, featureFlags map[string]string, callID string, opts MediaProcessorOpts) msdk.PCM16Processor

	RegisterTransferSIPParticipantTopic(sipCallId string) error
	DeregisterTransferSIPParticipantTopic(sipCallId string)

	OnInboundInfo(log logger.Logger, callInfo *rpc.SIPCall, headers Headers)
	OnSessionEnd(ctx context.Context, callIdentifier *CallIdentifier, state *CallState, reason string)
}

type HandlerInterceptor func(sipgo.RequestHandler) sipgo.RequestHandler

type Headers []sip.Header

type InboundAuth struct {
	Username string
	Password string
	Realm    string
}

type LatencyStats struct {
	Count atomic.Uint64
	SumNs atomic.Uint64
	MaxNs atomic.Uint64
}

type LatencyStatsSnapshot struct {
	Count uint64 `json:"count"`
	AvgNs uint64 `json:"avg_ns"`
	MaxNs uint64 `json:"max_ns"`
}

type LocalTag string

type MediaOptions struct {
	IP                   netip.Addr
	Ports                rtcconfig.PortRange
	MediaTimeoutInitial  time.Duration
	MediaTimeout         time.Duration
	SymmetricRTP         bool
	IgnoreLocalAddrInSDP bool // enable symmetric RTP if local IP is specified in SDP
	Stats                *PortStats
	EnableJitterBuffer   bool
	LogSignalChanges     bool
	DrainingIdleTimeout  time.Duration
	DrainingDuration     time.Duration
	Codecs               *msdk.CodecSet
	Encryption           sdp.Encryption
	DTMFAudio            bool
}

type MediaPort interface {
	Close()
	CloseWait()

	// GetOutboundAudioWriter returns the LK room -> SIP writer.
	GetOutboundAudioWriter() msdk.PCM16Writer
	// GetOutboundDTMFWriter returns the LK room -> SIP DTMF writer.
	GetOutboundDTMFWriter() msdk.WriteCloser[string]

	// WriteInboundAudioTo tells port where to write inbound SIP audio.
	//
	// MediaPort.Close() will propagate to the argument writer. The caller is
	// responsible for closing the returned media writer.
	WriteInboundAudioTo(w msdk.PCM16Writer) msdk.PCM16Writer

	// WriteInboundDTMFTo tells port where to write inbound SIP DTMF.
	//
	// MediaPort.Close() will propagate to the argument writer. The caller is
	// responsible for closing the returned media writer.
	WriteInboundDTMFTo(w msdk.WriteCloser[string]) msdk.WriteCloser[string]

	// If there is no offer, this generates an offer.
	// If there is an offer, this simply returns the SDP of that offer.
	// An offer is cleared once a negotiation is successful.
	GenerateOffer() ([]byte, error)

	// GenerateAnswer returns an encoded SDP answer for the given offer.
	// This does not arm the media timeout, use SetTimeout to do so.
	//
	// SIDE EFFECT: May cause a rebuild of the pipeline.
	GenerateAnswer(offer []byte) ([]byte, error)

	// ProcessAnswer processes an encoded SDP answer from the remote client. Returns an
	// error if the answer is invalid, the offer has not yet been generated, or
	// if media has already been negotiated.
	//
	// SIDE EFFECT: May cause a rebuild of the pipeline.
	ProcessAnswer(answer []byte) error

	GetLocalSDP() ([]byte, error)

	// NegotiatedAudio returns the audio configuration chosen by SDP negotiation.
	// Returns nil if media has not been negotiated yet.
	//
	// REQUIRES: The caller should not mutate the returned audio config.
	NegotiatedAudio() *sdp.AudioConfig

	// SetTimeout resets the media timeout with the given values.
	//
	// NOTE: This method is likely to go through additional changes.
	SetTimeout(initial, general time.Duration)

	Received() <-chan struct{}
	MediaTimeout() <-chan struct{}
}

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

type MediaProcessorOpts struct {
	InputSampleRate int
}

type MixerStatsSnapshot struct {
	Tracks       int64  `json:"tracks"`
	TracksTotal  uint64 `json:"tracks_total"`
	Restarts     uint64 `json:"restarts"`
	TimingResets uint64 `json:"timing_resets"`

	Mixes         uint64 `json:"mixes"`
	TimedMixes    uint64 `json:"mixes_timed"`
	JumpMixes     uint64 `json:"mixes_jump"`
	ZeroMixes     uint64 `json:"mixes_zero"`
	NegativeMixes uint64 `json:"mixes_negative"`

	InputSamples        uint64 `json:"input_samples"`
	InputFrames         uint64 `json:"input_frames"`
	InputSamplesDropped uint64 `json:"input_samples_dropped"`
	InputFramesDropped  uint64 `json:"input_frames_dropped"`

	MixedSamples uint64 `json:"mixed_samples"`
	MixedFrames  uint64 `json:"mixed_frames"`

	OutputSamples uint64 `json:"output_samples"`
	OutputFrames  uint64 `json:"output_frames"`

	WriteErrors  uint64 `json:"write_errors"`
	BlockedMixes uint64 `json:"blocked_mixes"`
}

type ParticipantConfig struct {
	Identity   string
	Name       string
	Metadata   string
	Attributes map[string]string
}

type ParticipantInfo struct {
	ID       string
	RoomName string
	Identity string
	Name     string
}

type PendingTransfer struct {
	CallID     string
	TransferTo string

	// TODO: record the transfer id here as soon as the transfer starts. It is
	// only known inside the worker goroutine today, so a waiter that gives up
	// before the outcome arrives reports a failure with no transfer id, and the
	// caller cannot match it against the transfer in their logs.
	Outcome atomic.Pointer[transferOutcome]
	Done    chan transferOutcome
}

type PortStats struct {
	Streams        atomic.Uint64
	Packets        atomic.Uint64
	IgnoredPackets atomic.Uint64
	InputPackets   atomic.Uint64
	FailedPackets  atomic.Uint64

	MuxStats rtpCountingStats

	AudioPackets atomic.Uint64
	AudioBytes   atomic.Uint64

	AudioInFrames   atomic.Uint64
	AudioInSamples  atomic.Uint64
	AudioOutFrames  atomic.Uint64
	AudioOutSamples atomic.Uint64

	AudioRX atomic.Uint64 // based on AudioInSamples
	AudioTX atomic.Uint64 // based on AudioOutSamples

	DTMFPackets atomic.Uint64
	DTMFBytes   atomic.Uint64

	JitterBufferPacketsLost    atomic.Uint64
	JitterBufferPacketsDropped atomic.Uint64

	LatencyInE2E LatencyStats
	LatencyOut   LatencyStats

	Closed atomic.Bool
	// contains filtered or unexported fields
}

type PortStatsSnapshot struct {
	Streams        uint64 `json:"streams"`
	Packets        uint64 `json:"packets"`
	IgnoredPackets uint64 `json:"packets_ignored"`
	InputPackets   uint64 `json:"packets_input"`
	FailedPackets  uint64 `json:"packets_failed"`

	MuxPackets        uint64 `json:"mux_packets"`
	MuxBytes          uint64 `json:"mux_bytes"`
	MuxResets         uint64 `json:"mux_resets"`
	MuxGaps           uint64 `json:"mux_gaps"`
	MuxGapsSum        uint64 `json:"mux_gaps_sum"`
	MuxLate           uint64 `json:"mux_late"`
	MuxLateSum        uint64 `json:"mux_late_sum"`
	MuxRapidPackets   uint64 `json:"mux_rapid_packets"`
	MuxDelayedPackets uint64 `json:"mux_delayed_packets"`
	MuxDelayedSum     uint64 `json:"mux_delayed_sum"`

	AudioPackets uint64 `json:"audio_packets"`
	AudioBytes   uint64 `json:"audio_bytes"`

	AudioInFrames   uint64 `json:"audio_in_frames"`
	AudioInSamples  uint64 `json:"audio_in_samples"`
	AudioOutFrames  uint64 `json:"audio_out_frames"`
	AudioOutSamples uint64 `json:"audio_out_samples"`

	AudioRX float64 `json:"audio_rx"`
	AudioTX float64 `json:"audio_tx"`

	DTMFPackets uint64 `json:"dtmf_packets"`
	DTMFBytes   uint64 `json:"dtmf_bytes"`

	JitterBufferPacketsLost    uint64 `json:"jitter_buffer_packets_lost"`
	JitterBufferPacketsDropped uint64 `json:"jitter_buffer_packets_dropped"`

	LatencyInE2E LatencyStatsSnapshot `json:"latency_in_e2e"`
	LatencyOut   LatencyStatsSnapshot `json:"latency_out"`

	Closed bool `json:"closed"`
}

type ReasonHeader struct {
	Type  string
	Cause int
	Text  string
}

type RemoteTag string

type RequestHandler func(req *sip.Request, tx sip.ServerTransaction) bool

type Result struct {
	Code   sip.StatusCode
	Status string
}

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

type RoomConfig struct {
	WsUrl            string
	Token            string
	RoomName         string
	Participant      ParticipantConfig
	RoomPreset       string
	RoomConfig       *livekit.RoomConfiguration
	JitterBuf        bool
	LogSignalChanges bool
}

type RoomInterface interface {
	Connect(ctx context.Context, conf *config.Config, rconf RoomConfig) error
	Closed() <-chan struct{}
	ClosedReason() livekit.DisconnectReason
	Subscribed() <-chan struct{}
	Room() *lksdk.Room
	Subscribe()
	Close() error
	CloseWithReason(reason livekit.DisconnectReason) error
	Participant() ParticipantInfo
	NewParticipantTrack(sampleRate int) (msdk.WriteCloser[msdk.PCM16Sample], error)
	NewTrack() *mixer.Input
	lksdk.RoomRPCInterface

	// WriteOutboundAudioTo tells the room where to send audio to.
	// Returns the previously-set writer (if one exists).
	WriteOutboundAudioTo(w msdk.PCM16Writer) msdk.PCM16Writer

	// WriteOutboundDTMFTo tells the room where to send DTMF to.
	// Returns the previously-set writer (if one exists).
	WriteOutboundDTMFTo(w msdk.WriteCloser[string]) msdk.WriteCloser[string]

	// GetInboundAudioWriter returns a writer that, when written to, writes
	// audio to the room.
	GetInboundAudioWriter() (msdk.PCM16Writer, error)
	// GetInboundDTMFWriter returns a writer that, when written to, writes DTMF
	// to the room.
	GetInboundDTMFWriter() msdk.WriteCloser[string]
}

type RoomStats struct {
	PublishedFrames  atomic.Uint64
	PublishedSamples atomic.Uint64
	PublishTX        atomic.Uint64

	// TrackSubscribes counts subscribe requests issued for remote tracks.
	// Attempts, not confirmations.
	TrackSubscribes atomic.Uint64

	// Resumes and Reconnects count the two ways the signal connection recovers
	// during a call, and are mutually exclusive. A resume keeps the peer
	// connections and subscriptions; a reconnect rebuilds them. Neither is
	// counted until the recovery succeeds.
	Resumes    atomic.Uint64
	Reconnects atomic.Uint64

	// Recovering is set while the signal connection is down. PublishedFrames
	// and PublishTX are counted before the track write, so they keep reporting a
	// healthy rate even though the audio is being dropped. Read them only when
	// this is false.
	Recovering atomic.Bool

	JitterBufferPacketsLost    atomic.Uint64
	JitterBufferPacketsDropped atomic.Uint64

	LatencyOutRecv LatencyStats // measures track recv → opus decode → mixer input.

	Mixer mixer.Stats

	Closed atomic.Bool
	// contains filtered or unexported fields
}

type RoomStatsSnapshot struct {
	// Stats quantifying total incoming traffic from all tracks
	InputPackets   uint64 `json:"input_packets"`
	InputBytes     uint64 `json:"input_bytes"`
	Resets         uint64 `json:"resets"`
	Gaps           uint64 `json:"gaps"`
	GapsSum        uint64 `json:"gaps_sum"`
	Late           uint64 `json:"late"`
	LateSum        uint64 `json:"late_sum"`
	DelayedPackets uint64 `json:"delayed_packets"`
	DelayedSum     uint64 `json:"delayed_sum"`
	RapidPackets   uint64 `json:"rapid_packets"`
	DataPackets    uint64 `json:"data_packets"`

	// Stats quantifying total outgoing traffic
	PublishedFrames  uint64  `json:"published_frames"`
	PublishedSamples uint64  `json:"published_samples"`
	PublishTX        float64 `json:"publish_tx"`

	JitterBufferPacketsLost    uint64 `json:"jitter_buffer_packets_lost"`
	JitterBufferPacketsDropped uint64 `json:"jitter_buffer_packets_dropped"`

	TrackSubscribes uint64 `json:"track_subscribes"`
	Resumes         uint64 `json:"resumes"`
	Reconnects      uint64 `json:"reconnects"`
	// Recovering reports whether the signal connection was down when the
	// snapshot was taken. PublishedFrames and PublishTX are unreliable while set.
	Recovering bool `json:"recovering"`

	LatencyOutRecv LatencyStatsSnapshot `json:"latency_out_recv"`

	Closed bool `json:"closed"`
}

type SDPError struct {
	Err error
}

type SIPClient interface {
	TransactionRequest(req *sip.Request, options ...sipgo.ClientRequestOption) (sip.ClientTransaction, error)
	WriteRequest(req *sip.Request, options ...sipgo.ClientRequestOption) error
	Close() error
}

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

type ServerOption func(s *Server)

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

type ServiceConfig struct {
	SignalingIP      netip.Addr
	SignalingIPLocal netip.Addr
	MediaIP          netip.Addr
}

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

type SignalLoggerOption func(*SignalLogger) error

type Signaling interface {
	Address() sip.Uri
	From() sip.Uri
	To() sip.Uri
	ID() LocalTag
	Tag() RemoteTag
	SIPCallID() string
	RemoteHeaders() Headers

	WriteRequest(req *sip.Request) error
	Transaction(req *sip.Request) (sip.ClientTransaction, error)

	Drop()
}

type SignalingTimestamps struct {
	// Inbound: INVITE received; Outbound: INVITE sent.
	InviteTime time.Time

	// Inbound: 100 Trying sent; Outbound: 100 Trying received.
	// Zero if 100 Trying was never sent/received.
	TryingTime time.Time

	// Inbound: first 180/183 sent; Outbound: first 180/183 received.
	RingingTime time.Time

	// Inbound: 200 OK sent; Outbound: 200 OK received.
	AcceptTime time.Time

	// Outbound only: time the API request was received (call creation).
	APITime time.Time

	// Outbound only: ACK sent after receiving 200 OK.
	AckTime time.Time
}

type SilenceSuppressionOption func(*silenceFiller)

type StateHandler interface {
	HandleUpdate(info *livekit.SIPCallInfo)
	HandleTransfer(ti *livekit.SIPTransferInfo)
	HandleCallContextRecorded(info *livekit.SIPCallInfo)
}

type StateUpdater interface {
	UpdateSIPCallState(ctx context.Context, req *rpc.UpdateSIPCallStateRequest, opts ...psrpc.RequestOption) (*emptypb.Empty, error)
	RecordCallContext(ctx context.Context, req *rpc.RecordCallContextRequest, opts ...psrpc.RequestOption) (*emptypb.Empty, error)
}

type Stats struct {
	Port   PortStats
	Room   RoomStats
	Closed atomic.Bool
}

type StatsSnapshot struct {
	Port   PortStatsSnapshot  `json:"port"`
	Room   RoomStatsSnapshot  `json:"room"`
	Mixer  MixerStatsSnapshot `json:"mixer"`
	Closed bool               `json:"closed"`
}

type SubscriptionState struct {
	State   string // substate: "active", "pending", "terminated", or an extension
	Reason  string // reason param: noresource, giveup, timeout, rejected, ...
	Expires int    // expires param in seconds, 0 if absent
}

type Transport string

type UDPConn interface {
	net.Conn
	ReadFromUDPAddrPort(b []byte) (n int, addr netip.AddrPort, err error)
	WriteToUDPAddrPort(b []byte, addr netip.AddrPort) (int, error)
}

type URI struct {
	User      string
	Host      string
	Addr      netip.AddrPort
	Transport Transport
}