@inworld/web-core/build/src/connection/web-socket.connection.d.ts

import { CapabilitiesConfiguration } from '../../proto/ai/inworld/engine/configuration/configuration.pb.js';
import { ClientRequest } from '../../proto/ai/inworld/engine/world-engine.pb.js';
import { InworldPacket as ProtoPacket } from '../../proto/ai/inworld/packets/packets.pb.js';
import { Awaitable, InternalClientConfiguration, LoadedScene, User } from '../common/data_structures/index.js';
import { Extension } from '../common/data_structures/extension.js';
import { HistoryItem } from '../common/data_structures/history.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 OpenSessionProps {
    name: string;
    client?: ClientRequest;
    user?: User;
    session: SessionToken;
    sessionContinuation?: SessionContinuation;
}
interface UpdateSessionProps {
    name?: string;
    gameSessionId?: string;
    capabilities?: CapabilitiesConfiguration;
    sessionContinuation?: SessionContinuation;
}
interface ConnectionProps<InworldPacketT extends InworldPacket = InworldPacket, HistoryItemT extends HistoryItem = HistoryItem> {
    config?: InternalClientConfiguration;
    onDisconnect: () => Awaitable<void>;
    onReady: () => Awaitable<void>;
    onError: (err: InworldError) => Awaitable<void>;
    onMessage: (packet: ProtoPacket) => Awaitable<void>;
    extension: Extension<InworldPacketT, HistoryItemT>;
    eventFactory: EventFactory;
}
export interface QueueItem<InworldPacketT> {
    getPacket: () => ProtoPacket;
    afterWriting?: (packet: InworldPacketT) => void;
    beforeWriting?: (packet: InworldPacketT) => Promise<void>;
    convertPacket?: (packet: ProtoPacket) => ProtoPacket;
}
export interface Connection<InworldPacketT> {
    close(): Promise<void>;
    isActive: () => boolean;
    openSession(props: OpenSessionProps): Promise<LoadedScene>;
    reopenSession(session: SessionToken): Promise<void>;
    updateSession(props: UpdateSessionProps): Promise<LoadedScene>;
    write(item: QueueItem<InworldPacketT>): void;
}
export declare class WebSocketConnection<InworldPacketT extends InworldPacket = InworldPacket, HistoryItemT extends HistoryItem = HistoryItem> implements Connection<InworldPacketT> {
    private connectionProps;
    private ws;
    private extension;
    private onMessage;
    private onError;
    constructor(props: ConnectionProps<InworldPacketT, HistoryItemT>);
    isActive(): boolean;
    openSession(props: OpenSessionProps): Promise<LoadedScene>;
    reopenSession(session: SessionToken): Promise<void>;
    updateSession(props: UpdateSessionProps): Promise<LoadedScene>;
    close(): Promise<void>;
    write(item: QueueItem<InworldPacketT>): Promise<void>;
    private combineWebSocket;
    private parseEvent;
    private onLoad;
    private getPackets;
    private getClient;
    private getUserConfiguration;
    private getUserId;
    private getContinuation;
}
export {};