/**
 * Authoritative type declarations for the `window.host` global injected by
 * the host runtime into guest webviews.
 *
 * Import this module (or `@paritytech/host-sdk/guest`) for type-safe access to
 * host extensions without manually declaring globals.
 */
import type { DataConnectedPayload, DataMessagePayload, DataBinaryPayload, DataClosedPayload, DataErrorPayload, DataIncomingCallPayload, MediaTrackReadyPayload, MediaConnectedPayload, MediaRemoteTrackPayload, MediaClosedPayload, MediaErrorPayload, MediaIncomingCallPayload, MediaSignalingProgressPayload, MediaTrackStoppedPayload, MediaCallStateChangedPayload, CrdtAwarenessPayload, CrdtJoinResult, CrdtPeerChangePayload, CrdtRemoteUpdatePayload, MeshCapability, MeshControlEnvelope, MeshObjectResult, MeshOpaqueHandle, MeshPrivateControlPayload, MeshPrivateObjectRef, MeshPresencePayload, MeshPrivateReceiptPayload, MeshHeartbeatPayload, MeshQueryPayload, MeshReplyPayload, MeshScopedQueryPayload, MeshScopedReplyPayload, MeshTopicPayload, StatementEventPayload } from "../events.js";
import type { HostStoreStatus } from "../types.js";
import type { BridgeMetadata } from "../bridge/contract.js";
export interface HostDataExtension {
    getPeerId(): Promise<string>;
    connect(peerAddress: string): Promise<number>;
    startListening(address: string): Promise<void>;
    close(connId: number): Promise<void>;
    send(connId: number, data: string): Promise<void>;
    sendBytes(connId: number, data: Uint8Array): Promise<void>;
}
export interface HostFilesExtension {
    save(filename: string, dataBase64: string): Promise<void>;
}
export interface HostMediaExtension {
    getUserMedia(constraints: {
        audio: boolean;
        video: boolean;
    }): Promise<void>;
    getDisplayMedia(): Promise<void>;
    connect(peer: string, trackIds?: number[]): Promise<number>;
    accept(peer?: string): Promise<number>;
    reject(peer?: string): Promise<void>;
    close(sessionId: number): Promise<void>;
    attachTrack(trackId: number, elementId: string): Promise<void>;
    getPeerId(): Promise<string>;
    startListening(address: string): Promise<void>;
    setTrackEnabled(trackId: number, enabled: boolean): Promise<void>;
    groupConnect(peers: string[], trackIds?: number[]): Promise<string>;
    groupAccept(peer: string, trackIds?: number[]): Promise<number>;
    addTrack(sessionId: number, trackId: number): Promise<void>;
    removeTrack(sessionId: number, trackId: number): Promise<void>;
    getStats(sessionId: number): Promise<CallStats>;
}
export type HostClawMode = "disabled" | "remote" | "local" | "hybrid";
export type HostClawTask = "ask" | "explain" | "summarize" | "plan";
export interface HostClawAskRequest {
    prompt: string;
    task?: HostClawTask;
    productId?: string;
    conversationId?: string;
    context?: Record<string, unknown>;
}
export interface HostClawAskResponse {
    answer: string;
    provider?: string;
    model?: string;
    mode?: HostClawMode;
    error?: string;
}
export interface HostClawStatus {
    available: boolean;
    mode: HostClawMode;
    provider?: string;
    model?: string;
    requiresUserKey: boolean;
}
export interface HostClawExtension {
    ask(request: HostClawAskRequest): Promise<HostClawAskResponse>;
    status(): Promise<HostClawStatus>;
}
export interface CallStats {
    sessionId: number;
    audioBytesReceived?: number;
    videoBytesReceived?: number;
    packetLossFraction?: number;
    jitterSeconds?: number;
    roundTripTimeSeconds?: number;
    connectionType?: string;
    timestampMs: number;
}
export interface HostCrdtExtension {
    join(roomId: string, opts?: {
        transport?: string;
    }): Promise<CrdtJoinResult>;
    applyUpdate(roomId: string, dataBase64: string): Promise<boolean>;
    getStateVector(roomId: string): Promise<string>;
    getFullState(roomId: string): Promise<string>;
    setAwareness(roomId: string, state: Record<string, unknown>): Promise<boolean>;
    destroy(roomId: string): Promise<boolean>;
}
export interface HostMeshExtension {
    transport: {
        publish(topic: string, dataBase64: string): Promise<boolean>;
        subscribe(topic: string): Promise<boolean>;
        heartbeat(streamId: string, authorId: string, earliestRetainedSeq: number, latestAvailableSeq: number): Promise<boolean>;
    };
    objects: {
        put(path: string, dataBase64: string, retentionUntilMs?: number): Promise<boolean>;
        get(path: string): Promise<string | null>;
        getResult(path: string): Promise<MeshObjectResult>;
    };
    query: {
        request(path: string, dataBase64: string): Promise<string>;
        scopedRequest(request: {
            requestId: string;
            requesterId: string;
            path: string;
            dataBase64: string;
            capability: {
                capabilityId: string;
                pathPrefix: string;
                targetId: string;
                expiresAtMs: number;
                maxUses: number;
            };
        }): Promise<boolean>;
        respond(requestId: string, dataBase64: string): Promise<boolean>;
        scopedRespond(reply: {
            requestId: string;
            responderId: string;
            dataBase64: string;
            capabilityId: string;
        }): Promise<boolean>;
    };
    private?: {
        objects?: {
            put(dataBase64: string, policy?: {
                expiresAtMs?: number;
                suppressPreviews?: boolean;
            }): Promise<MeshPrivateObjectRef>;
            get(handle: MeshOpaqueHandle, capability: MeshCapability): Promise<MeshObjectResult>;
        };
        query?: {
            request(handle: MeshOpaqueHandle, capability: MeshCapability, dataBase64: string): Promise<string>;
        };
        control?: {
            publish(capability: MeshCapability, envelope: MeshControlEnvelope): Promise<boolean>;
            subscribe(capability: MeshCapability): Promise<boolean>;
        };
        receipts?: {
            publish(capability: MeshCapability, dataBase64: string): Promise<boolean>;
            subscribe(capability: MeshCapability): Promise<boolean>;
        };
    };
    status: {
        status(): Promise<{
            health: string;
            transport: string;
            pendingPublishes: number;
            pendingQueries: number;
            retainedObjects: number;
            repairableObjects: number;
            expiringObjects: number;
            nextExpiryMs?: number | null;
            lastError: string | null;
        }>;
    };
}
/** Maps event name → callback payload type for `host.on` / `host.off`. */
export interface HostEventMap {
    dataConnected: DataConnectedPayload;
    dataMessage: DataMessagePayload;
    dataBinary: DataBinaryPayload;
    dataClosed: DataClosedPayload;
    dataError: DataErrorPayload;
    dataIncomingCall: DataIncomingCallPayload;
    mediaTrackReady: MediaTrackReadyPayload;
    mediaConnected: MediaConnectedPayload;
    mediaRemoteTrack: MediaRemoteTrackPayload;
    mediaClosed: MediaClosedPayload;
    mediaError: MediaErrorPayload;
    mediaIncomingCall: MediaIncomingCallPayload;
    mediaSignalingProgress: MediaSignalingProgressPayload;
    mediaTrackStopped: MediaTrackStoppedPayload;
    mediaCallStateChanged: MediaCallStateChangedPayload;
    statement: StatementEventPayload;
    meshTopic: MeshTopicPayload;
    meshQuery: MeshQueryPayload;
    meshReply: MeshReplyPayload;
    meshScopedQuery: MeshScopedQueryPayload;
    meshScopedReply: MeshScopedReplyPayload;
    meshPresence: MeshPresencePayload;
    meshHeartbeat: MeshHeartbeatPayload;
    meshPrivateControl: MeshPrivateControlPayload;
    meshPrivateReceipt: MeshPrivateReceiptPayload;
    crdtRemoteUpdate: CrdtRemoteUpdatePayload;
    crdtAwareness: CrdtAwarenessPayload;
    crdtPeerChange: CrdtPeerChangePayload;
}
export type HostEventName = keyof HostEventMap;
/** Bandersnatch ring-VRF extension. Optional — only present when the host has a VRF backend. */
export interface HostVrfExtension {
    /** Derive the Bandersnatch public member key (32 bytes). */
    deriveMemberKey(): Promise<Uint8Array>;
    /** Sign a message with the Bandersnatch key (proof of ownership). */
    sign(message: Uint8Array): Promise<Uint8Array>;
    /** Create a ring-VRF proof. CPU-intensive — host offloads to a worker. */
    createProof(members: Uint8Array[], context: Uint8Array, message: Uint8Array): Promise<Uint8Array>;
    /** Derive a context-specific alias (32 bytes). */
    aliasInContext(context: Uint8Array): Promise<Uint8Array>;
}
export interface HostIdentityNamespace {
    /** Resolve a username to a hex account ID. Throws if not supported. */
    resolveUsername(username: string): Promise<string | null>;
}
export interface HostGlobal {
    /** Immutable metadata for version/profile/capability feature detection. */
    __bridge: BridgeMetadata;
    ext: {
        claw?: HostClawExtension;
        data: HostDataExtension;
        files: HostFilesExtension;
        media: HostMediaExtension;
        mesh?: HostMeshExtension;
        crdt?: HostCrdtExtension;
        /** Bandersnatch ring-VRF. Optional — absent when the host has no VRF backend. */
        vrf?: HostVrfExtension;
    };
    /** Statement Store pub/sub API. Present when the host runtime supports statements. */
    statements?: {
        subscribe(channel: string): Promise<boolean>;
        write(channel: string, data: string): Promise<boolean>;
        status(): Promise<HostStoreStatus>;
    };
    /** Persistent key/value storage scoped to the app. */
    storage?: {
        get(key: string): Promise<string | null>;
        set(key: string, value: string): Promise<boolean>;
        remove(key: string): Promise<boolean>;
    };
    /** Return the hex-encoded address of the current account. */
    getAddress?(): Promise<string>;
    /** Identity helpers. Presence and support are also reflected in `__bridge`. */
    identity?: HostIdentityNamespace;
    on<E extends HostEventName>(event: E, callback: (payload: HostEventMap[E]) => void): void;
    off<E extends HostEventName>(event: E, callback: (payload: HostEventMap[E]) => void): void;
}
/** Minimal MessagePort-compatible interface used by the host bridge shim. */
export interface HostApiPort {
    postMessage(data: ArrayBuffer | Uint8Array | ArrayBufferView): void;
    addEventListener(type: "message", handler: (event: {
        data: unknown;
    }) => void): void;
    removeEventListener(type: "message", handler: (event: {
        data: unknown;
    }) => void): void;
    start(): void;
}
declare global {
    interface Window {
        /** Injected by the host runtime. May be undefined outside a host webview. */
        host?: HostGlobal;
        /** Binary SCALE bridge port (or shim with the same interface on web). */
        __HOST_API_PORT__?: HostApiPort;
    }
}
//# sourceMappingURL=types.d.ts.map