import { ClientRequest } from '../../proto/ai/inworld/engine/world-engine.pb.js';
import { InworldPacket as ProtoPacket } from '../../proto/ai/inworld/packets/packets.pb.js';
import { AudioSessionState, Awaitable, CancelResponsesProps, ChangeSceneProps, ClientConfiguration, ConversationState, GenerateSessionTokenFn, InternalClientConfiguration, User } from '../common/data_structures/index.js';
import { ConvesationInterface, Extension } from '../common/data_structures/extension.js';
import { HistoryChangedProps, HistoryItem } from '../common/data_structures/history.js';
import { InworldHistory } from '../components/history.js';
import { GrpcAudioPlayback } from '../components/sound/grpc_audio.playback.js';
import { GrpcWebRtcLoopbackBiDiSession } from '../components/sound/grpc_web_rtc_loopback_bidi.session.js';
import { Character } from '../entities/character.entity.js';
import { SessionContinuation } from '../entities/continuation/session_continuation.entity.js';
import { InworldError } from '../entities/error.entity.js';
import { InworldPacket } from '../entities/packets/inworld_packet.entity.js';
import { SessionToken } from '../entities/session_token.entity.js';
import { EventFactory } from '../factories/event.js';
interface ConnectionProps<InworldPacketT extends InworldPacket = InworldPacket, HistoryItemT extends HistoryItem = HistoryItem> {
    name: string;
    user?: User;
    client?: ClientRequest;
    config?: ClientConfiguration;
    sessionContinuation?: SessionContinuation;
    onReady?: () => Awaitable<void>;
    onError?: (err: InworldError) => Awaitable<void>;
    onMessage?: (packet: InworldPacketT) => Awaitable<void>;
    onWarning?: (packet: InworldPacketT) => Awaitable<void>;
    onDisconnect?: () => Awaitable<void>;
    onInterruption?: (props: CancelResponsesProps) => Awaitable<void>;
    onHistoryChange?: (history: HistoryItem[], props: HistoryChangedProps<HistoryItemT>) => Awaitable<void>;
    grpcAudioPlayer: GrpcAudioPlayback<InworldPacketT>;
    webRtcLoopbackBiDiSession: GrpcWebRtcLoopbackBiDiSession;
    generateSessionToken: GenerateSessionTokenFn;
    extension?: Extension<InworldPacketT, HistoryItemT>;
}
export declare class ConnectionService<InworldPacketT extends InworldPacket = InworldPacket, HistoryItemT extends HistoryItem = HistoryItem> {
    private player;
    private state;
    private audioSessionAction;
    private scene;
    private config;
    private characterMapping;
    private sceneIsLoaded;
    private session;
    private connection;
    private connectionProps;
    private eventFactory;
    private intervals;
    private packetQueue;
    private packetQueuePercievedLatency;
    private disconnectTimeoutId;
    private reconnectTimeoutId;
    private currentAudioConversation;
    readonly onDisconnect: () => Awaitable<void>;
    readonly onError: (err: InworldError) => Awaitable<void>;
    readonly onWarning: (message: InworldPacketT) => Awaitable<void>;
    readonly onMessage: (packet: ProtoPacket) => Awaitable<void>;
    readonly onReady: () => Awaitable<void>;
    readonly onHistoryChange: (history: HistoryItem[], props: HistoryChangedProps<HistoryItemT>) => Awaitable<void> | undefined;
    readonly history: InworldHistory;
    readonly conversations: Map<string, {
        service: ConvesationInterface<InworldPacketT>;
        state: ConversationState;
    }>;
    private cancelResponses;
    private extension;
    private MAX_LATENCY_QUEUE_SIZE;
    private previousError;
    private packetsInProgress;
    constructor(props?: ConnectionProps<InworldPacketT, HistoryItemT>);
    isActive(): boolean;
    isConnecting(): boolean;
    isInactive(): boolean;
    isAutoReconnected(): boolean;
    getSceneName(): string;
    getSessionId(): string;
    getCurrentAudioConversation(): ConvesationInterface<InworldPacketT>;
    setCurrentAudioConversation(conversation?: ConvesationInterface<InworldPacketT>): void;
    openManually(): Promise<void>;
    close(): Promise<void>;
    getHistory(): HistoryItem[];
    clearHistory(): void;
    getEventFactory(): EventFactory;
    getTranscript(): string;
    getConfig(): InternalClientConfiguration;
    getClientConfig(): ClientConfiguration;
    getCharacters(): Promise<Character[]>;
    getCurrentCharacter(): Promise<Character>;
    getCharactersByIds(ids: string[]): Character[];
    getCharactersByResourceNames(names: string[]): Character[];
    setCurrentCharacter(character: Character): void;
    removeCharacters(names: string[]): void;
    open({ force }?: {
        force?: boolean;
    }): Promise<void>;
    change(name: string, props?: ChangeSceneProps): Promise<void>;
    send(getPacket: () => ProtoPacket, props?: {
        enforceHighPriority?: boolean;
    }): Promise<InworldPacketT>;
    setAudioSessionAction(action: AudioSessionState): void;
    getAudioSessionAction(): AudioSessionState;
    interrupt(): Promise<void>;
    private write;
    private afterWriting;
    private beforeWriting;
    private getActualCharacterId;
    private loadToken;
    ensureSessionToken(props?: {
        beforeLoading: () => void;
    }): Promise<SessionToken>;
    addInterval(interval: NodeJS.Timeout): void;
    removeInterval(interval: NodeJS.Timeout): void;
    markPacketAsHandled(packet: InworldPacket): void;
    private scheduleDisconnect;
    private setPreviousState;
    private cancelScheduler;
    private cancelReconnectScheduler;
    private reopenConversations;
    private releaseQueue;
    private clearQueue;
    private onReadyHandler;
    private onDisconnectHandler;
    private onErrorHandler;
    private onWarningHandler;
    private onMessageHandler;
    private onHistoryChangeHandler;
    private initializeConnection;
    private initializeExtension;
    private interruptByPacket;
    private sendCancelResponses;
    private addPacketToHistory;
    private getPacketsToSentOnOpen;
    private ensureCurrentCharacter;
    private setSceneFromProtoEvent;
    private buildConfiguration;
    private ensureGateway;
    private pushToPerceivedLatencyQueue;
    private findLastAudioSessionIndexes;
}
export {};