/** Minimal logging interface. Compatible with `console` but allows custom loggers. */
export interface Logger {
    info(...args: unknown[]): void;
    warn(...args: unknown[]): void;
    error(...args: unknown[]): void;
    debug(...args: unknown[]): void;
}
export declare enum ConnectionError {
    websocket = "websocket",
    authorization = "authorization",
    lostConnection = "lostConnection",
    proxyDisabled = "proxyDisabled",
    transcodingDisabled = "transcodingDisabled",
    mjpegDisabled = "mjpegDisabled",
    invalidAccessToken = "invalidAccessToken",
    transcodingRequired = "transcodingRequired"
}
/** Delivery method for the WebRTC media transport. */
export type DeliveryMethod = 'srtp' | 'mse';
export declare enum AvailableStreams {
    PRIMARY = 0,
    SECONDARY = 1
}
export declare enum ApiVersions {
    v1 = "v1",
    v2 = "v2"
}
export declare enum TargetStream {
    AUTO = "AUTO",
    HIGH = "HIGH",
    LOW = "LOW"
}
export declare enum RequiresTranscoding {
    MJPEG = 7
}
/** Well-known codec identifiers from the mediaserver Stream.codec field. */
export declare const KnownCodec: {
    readonly H264: 27;
    readonly H265: 173;
    readonly MJPEG: 7;
};
/**
 * Returns true if the codec can be delivered over WebRTC SRTP without transcoding.
 * Only H264 and H265 are natively supported — anything else (MJPEG, etc.) forces
 * the mediaserver to transcode, typically to VP8.
 */
export declare function isNativeWebRtcCodec(codec: number): boolean;
/** Peer connection lifecycle states (new in v2). */
export declare enum PeerState {
    connecting = "connecting",
    connected = "connected",
    failed = "failed"
}
export interface SdpInit {
    sdp: RTCSessionDescriptionInit;
}
export interface IceInit {
    ice: RTCIceCandidateInit;
}
export interface MimeInit {
    mime: string;
}
export interface TranscodingInit {
    transcoding: {
        video: boolean;
        audio?: boolean;
    };
}
export interface ErrorMsg {
    error: unknown;
}
export type SignalingMessage = SdpInit | IceInit | MimeInit | TranscodingInit | ErrorMsg;
export interface Stream {
    codec: number;
    encoderIndex: AvailableStreams;
}
/**
 * Pre-resolved connection context. When provided, skips host resolution/ping request.
 */
export interface ConnectionContext {
    /** The resolved host URL after following redirects from ping. */
    resolvedHost: string;
    /** The moduleGuid returned from ping response (which server the relay connected to). */
    moduleGuid?: string;
}
/**
 * Pre-resolved API context. When provided, skips version detection request.
 */
export interface ApiContext {
    /** API version to use for endpoint construction. Skips GET /rest/v2/system/info. */
    version: ApiVersions;
    /**
     * One-time token for V2 API WebSocket authentication.
     * Can be a static string or a factory function (recommended for fresh tokens).
     * Note: Tokens expire in ~10 seconds and are single-use - prefer factory function.
     */
    oneTimeToken?: string | (() => string | Promise<string>);
}
export interface WebRtcUrlConfigUnknown {
    systemId: string;
    cameraId: string;
    serverId?: string;
    accessToken: string | (() => string | Promise<string>);
    targetStream: TargetStream;
    position?: number;
    speed?: 'unlimited' | number;
    /** Available streams from camera mediaStreams data. If provided, skips API detection. */
    availableStreams?: AvailableStreams[];
    /** Full mediaStreams data from camera. If provided, skips device info API call. */
    mediaStreams?: Stream[];
    /**
     * Pre-resolved connection context. When provided, skips ping/host resolution request.
     * Use this when the caller has already determined the relay connection details.
     */
    connectionContext?: ConnectionContext;
    /**
     * Pre-resolved API context. When provided, skips version detection request.
     * Use this when the system version is already known from NxSystemInfo.
     */
    apiContext?: ApiContext;
    /**
     * Explicit proxy mode override.
     * - true: Force proxy mode (route through relay-connected server)
     * - false: Force direct connection to target server
     * - undefined: Auto-detect by comparing moduleGuid with serverId
     *
     * Note: Proxy is needed when target server is different from relay-connected server,
     * to avoid unnecessary inter-server video traffic routing.
     */
    useProxy?: boolean;
}
export interface WebRtcUrlConfigV1 extends WebRtcUrlConfigUnknown {
    allowTranscoding?: boolean;
    apiVersion: ApiVersions.v1;
}
export interface WebRtcUrlConfigV2 extends WebRtcUrlConfigUnknown {
    apiVersion: ApiVersions.v2;
}
export type WebRtcUrlConfig = WebRtcUrlConfigV1 | WebRtcUrlConfigV2 | WebRtcUrlConfigUnknown;
export type TimeStampMessage = ({
    timestamp: number;
} | {
    timestampMs: number;
}) & {
    rtpTimestamp: number;
};
export interface StreamChangeMessage {
    timestamp: -1;
    status: 301;
}
/** @deprecated Use TimeStampMessage directly. This alias will be removed in a future version. */
export type DataChannelMessage = TimeStampMessage;
export declare const isRequiresTranscoding: (codec: string | number) => codec is RequiresTranscoding;
export declare const isTimeStampMessage: (message: unknown) => message is TimeStampMessage;
declare const confirmationMessage: {
    readonly timestamp: -1;
    readonly status: 200;
};
export declare const isConfirmationMessage: (message: unknown) => message is typeof confirmationMessage;
export declare const isStreamChangeMessage: (message: unknown) => message is StreamChangeMessage;
export declare const isTranscodingMessage: (message: unknown) => message is TranscodingInit;
export declare const isMimeInit: (message: unknown) => message is MimeInit;
export interface ConnectionType {
    usingRelay: boolean;
    localAddress: string;
    remoteAddress: string;
    localCandidateType: RTCIceCandidateType;
    remoteCandidateType: RTCIceCandidateType;
}
/** Detail for the track event emitted when a remote media track is received. */
export interface TrackEventDetail {
    track: MediaStreamTrack;
    streams: readonly MediaStream[];
}
/** Detail for timestamp events parsed from the data channel. */
export interface TimestampEventDetail {
    /** Seconds-based timestamp (from `timestamp` field) or `undefined` if only `timestampMs` was present. */
    timestamp?: number;
    /** Milliseconds-based timestamp (from `timestampMs` field) or `undefined` if only `timestamp` was present. */
    timestampMs?: number;
    rtpTimestamp: number;
}
/** Detail for peer connection state change events. */
export interface StateChangeEventDetail {
    state: PeerState;
    previousState: PeerState | null;
}
/** Detail for stream-change events (server-initiated stream switch). */
export interface StreamChangeEventDetail {
    stream: AvailableStreams;
}
/** Detail for transcoding events (server signals transcoding is active). */
export interface TranscodingEventDetail {
    video: boolean;
    audio?: boolean;
}
/** Detail for delivery method events (server provides MSE mime type). */
export interface DeliveryMethodEventDetail {
    method: DeliveryMethod;
    mime?: string;
}
export interface BBox {
    x: number;
    y: number;
    width: number;
    height: number;
}
/** @deprecated Use BBox instead */
export type BoundingBox = BBox;
/** A key-value attribute attached to an analytics object. */
export interface ObjectAttribute {
    name: string;
    value: string;
}
/** A single detected object within an analytics metadata packet. */
export interface ObjectMetadata {
    typeId: string;
    trackId: string;
    confidence?: number;
    boundingBox: BBox;
    attributes?: ObjectAttribute[];
}
/** The analytics metadata packet received on the data channel. */
export interface ObjectMetadataPacket {
    deviceId: string;
    timestampUs: number;
    durationUs?: number;
    streamIndex?: string;
    analyticsEngineId?: string;
    objectMetadataList: ObjectMetadata[];
}
/** The top-level envelope for a metadata data-channel message. */
export interface MetadataMessage {
    metadata: ObjectMetadataPacket;
}
/** Detail for analytics metadata events from the data channel. */
export interface MetadataEventDetail {
    metadata: ObjectMetadataPacket;
}
export declare const isMetadataMessage: (message: unknown) => message is MetadataMessage;
export {};
//# sourceMappingURL=types.d.ts.map