/** Connection states exposed by the SDK. */
export declare const EquosConnectionState: {
    readonly Disconnected: "disconnected";
    readonly Connecting: "connecting";
    readonly Connected: "connected";
    readonly Reconnecting: "reconnecting";
};

export declare type EquosConnectionStateType = (typeof EquosConnectionState)[keyof typeof EquosConnectionState];

export declare interface EquosContextMessage {
    type: typeof EquosInboundMessageType.Context;
    content: string;
}

export declare class EquosConversation {
    private readonly config;
    private readonly autoPublishMic;
    private currentMode;
    private room;
    private connectionState;
    private attachedElements;
    private listeners;
    constructor(options: EquosConversationOptions);
    on<K extends keyof EquosEventMap>(event: K, listener: EquosEventMap[K]): this;
    off<K extends keyof EquosEventMap>(event: K, listener: EquosEventMap[K]): this;
    private emit;
    get state(): EquosConnectionStateType;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    get mode(): EquosModeType;
    setMode(mode: EquosModeType): void;
    sendText(text: string): void;
    sendContext(content: string): void;
    setMicrophoneEnabled(enabled: boolean): Promise<void>;
    setCameraEnabled(enabled: boolean): Promise<void>;
    setScreenShareEnabled(enabled: boolean): Promise<void>;
    attach(element: HTMLMediaElement): void;
    detach(element: HTMLMediaElement): void;
    private setConnectionState;
    private requireRoom;
    private publishData;
    private isTrackAllowed;
    private isAgent;
    private attachAgentTracks;
    private detachAllElements;
    private registerRoomHandlers;
}

export declare interface EquosConversationConfig {
    /** LiveKit WebSocket endpoint (e.g. wss://lk.example.com) */
    wsUrl: string;
    /** Room access token */
    token: string;
    /** Identity of the agent participant (to filter tracks/events) */
    agentIdentity?: string;
}

export declare interface EquosConversationOptions {
    config: EquosConversationConfig;
    /** If true, automatically enable mic on connect. Default: true */
    autoPublishMic?: boolean;
    /** Conversation mode. Default: 'video' */
    mode?: EquosModeType;
}

export declare interface EquosErrorMessage {
    type: typeof EquosOutboundMessageType.Error;
    code: string;
}

/** Events emitted by EquosConversation. */
export declare const EquosEvent: {
    readonly Utterance: "utterance";
    readonly Trigger: "trigger";
    readonly Interrupt: "interrupt";
    readonly ExpireSoon: "expire_soon";
    readonly Error: "error";
    readonly ConnectionStateChanged: "connectionStateChanged";
    readonly AgentConnected: "agentConnected";
    readonly AgentDisconnected: "agentDisconnected";
    readonly ModeChanged: "modeChanged";
    readonly DataReceived: "dataReceived";
};

export declare interface EquosEventMap {
    [EquosEvent.Utterance]: (msg: EquosUtteranceMessage) => void;
    [EquosEvent.Interrupt]: (msg: EquosInterruptMessage) => void;
    [EquosEvent.Trigger]: (msg: EquosTriggerMessage) => void;
    [EquosEvent.ExpireSoon]: (msg: EquosExpireSoonMessage) => void;
    [EquosEvent.Error]: (msg: EquosErrorMessage) => void;
    [EquosEvent.ConnectionStateChanged]: (state: EquosConnectionStateType) => void;
    [EquosEvent.AgentConnected]: () => void;
    [EquosEvent.AgentDisconnected]: () => void;
    [EquosEvent.ModeChanged]: (mode: EquosModeType) => void;
    [EquosEvent.DataReceived]: (msg: EquosOutboundMessage) => void;
}

export declare interface EquosExpireSoonMessage {
    type: typeof EquosOutboundMessageType.ExpireSoon;
    seconds_remaining: number;
}

export declare type EquosInboundMessage = EquosContextMessage | EquosUsrTextMessage;

/** Message types sent FROM the SDK TO the agent (inbound to agent). */
export declare const EquosInboundMessageType: {
    readonly Context: "context";
    readonly UsrText: "usr.txt";
};

export declare interface EquosInterruptMessage {
    type: typeof EquosOutboundMessageType.Interrupt;
}

/** Conversation modes controlling which agent media is played. */
export declare const EquosMode: {
    readonly Text: "text";
    readonly Audio: "audio";
    readonly Video: "video";
};

export declare type EquosModeType = (typeof EquosMode)[keyof typeof EquosMode];

export declare type EquosOutboundMessage = EquosInterruptMessage | EquosUtteranceMessage | EquosTriggerMessage | EquosExpireSoonMessage | EquosErrorMessage;

/** Message types sent FROM the agent TO the SDK (outbound from agent). */
export declare const EquosOutboundMessageType: {
    readonly Interrupt: "interrupt";
    readonly Utterance: "utterance";
    readonly Trigger: "trigger";
    readonly ExpireSoon: "expire_soon";
    readonly Error: "error";
};

declare interface EquosTriggerMessage {
    type: typeof EquosOutboundMessageType.Trigger;
    name: string;
    params: Record<string, unknown>;
}

export declare interface EquosUsrTextMessage {
    type: typeof EquosInboundMessageType.UsrText;
    text: string;
}

export declare interface EquosUtterance {
    author: 'agent' | 'user';
    content: string;
    recordedAt: string;
    finished: boolean;
}

export declare interface EquosUtteranceMessage {
    type: typeof EquosOutboundMessageType.Utterance;
    utterance: EquosUtterance;
}

export { }