import { HostRuntime, type HostApiAccount } from "./host-runtime.js";
import { HostRuntimeRegistry } from "./host-runtime-registry.js";
import { type TrustedOriginMatcher } from "./scoped-frame.js";
import type { ChainStatus } from "./chain.js";
import type { RuntimeChainService } from "./runtime-chain-service.js";
import type { AccountCreateProofErrorKind, AccountRequestCredentialsErrorKind, HostApiOutcome, PaymentBalance, PaymentStatus } from "./types.js";
type HostRuntimeConstructorArg = ConstructorParameters<typeof HostRuntime>[0];
type HostRuntimePort = MessagePort;
export interface RemoteHostRuntimeSession {
    readonly productId: string;
    handleMessage(raw: Uint8Array): Promise<HostApiOutcome>;
    reset(): Promise<void>;
    forgetRequest(requestId: string): Promise<void>;
    isFollowRequest(requestId: string): Promise<boolean>;
    encodeSignResponse(requestId: string, requestTag: number, signature: Uint8Array): Promise<Uint8Array>;
    encodeSignError(requestId: string, requestTag: number): Promise<Uint8Array>;
    encodeAccountGetResponse(requestId: string, publicKey: Uint8Array, name?: string | null): Promise<Uint8Array>;
    encodeAccountGetError(requestId: string, errorKind: AccountRequestCredentialsErrorKind, reason?: string | null): Promise<Uint8Array>;
    encodeAccountGetAliasResponse(requestId: string, context: Uint8Array, alias: Uint8Array): Promise<Uint8Array>;
    encodeAccountGetAliasError(requestId: string, errorKind: AccountRequestCredentialsErrorKind, reason?: string | null): Promise<Uint8Array>;
    encodeAccountCreateProofResponse(requestId: string, proof: Uint8Array): Promise<Uint8Array>;
    encodeAccountCreateProofError(requestId: string, errorKind: AccountCreateProofErrorKind, reason?: string | null): Promise<Uint8Array>;
    encodeDevicePermissionResponse(requestId: string, granted: boolean): Promise<Uint8Array>;
    encodeDevicePermissionError(requestId: string): Promise<Uint8Array>;
    encodeRemotePermissionResponse(requestId: string, granted: boolean): Promise<Uint8Array>;
    encodeRemotePermissionError(requestId: string): Promise<Uint8Array>;
    encodeCreateTransactionResponse(requestId: string, signedTxBytes: Uint8Array): Promise<Uint8Array>;
    encodeCreateTransactionError(requestId: string): Promise<Uint8Array>;
    encodeCreateTxNonProductResponse(requestId: string, signedTxBytes: Uint8Array): Promise<Uint8Array>;
    encodeCreateTxNonProductError(requestId: string): Promise<Uint8Array>;
    encodePaymentBalance(requestId: string, balance: PaymentBalance): Promise<Uint8Array>;
    encodePaymentBalanceInterrupt(requestId: string): Promise<Uint8Array>;
    encodePaymentTopUpResponse(requestId: string): Promise<Uint8Array>;
    encodePaymentTopUpError(requestId: string, reason: string): Promise<Uint8Array>;
    encodePaymentRequestResponse(requestId: string, receiptId: string): Promise<Uint8Array>;
    encodePaymentRequestError(requestId: string, reason: string): Promise<Uint8Array>;
    encodePaymentStatus(requestId: string, status: PaymentStatus): Promise<Uint8Array>;
    encodePaymentStatusInterrupt(requestId: string): Promise<Uint8Array>;
    encodeChainQueryResponse(requestId: string, jsonRpcResult: string): Promise<Uint8Array>;
    encodeChainQueryError(requestId: string): Promise<Uint8Array>;
    encodeChainRpcResponse(requestId: string, requestTag: number, jsonRpcMessage: string): Promise<Uint8Array>;
    encodeChainRpcError(requestId: string, requestTag: number, reason: string): Promise<Uint8Array>;
    encodeNavigateResponse(requestId: string): Promise<Uint8Array>;
    encodePushNotificationResponse(requestId: string): Promise<Uint8Array>;
    encodeChainFollowStop(requestId: string): Promise<Uint8Array>;
    encodeChainNotification(requestId: string, jsonRpcMessage: string): Promise<Uint8Array | null>;
    encodeStorageReadResponse(requestId: string, value: Uint8Array | null): Promise<Uint8Array>;
    encodeStorageWriteResponse(requestId: string): Promise<Uint8Array>;
    encodeStorageClearResponse(requestId: string): Promise<Uint8Array>;
}
export interface RemoteHostRuntime {
    setAccounts(accounts: readonly HostApiAccount[]): Promise<void>;
    clearAccounts(): Promise<void>;
    setSupportedChains(chains: readonly Uint8Array[]): Promise<void>;
    session(productId: string): RemoteHostRuntimeSession;
    destroySession(productId: string): Promise<void>;
    reset(): Promise<void>;
    destroy(): void;
}
export interface RemoteRuntimeChainService {
    statuses(): Promise<ChainStatus[]>;
    connect(chainName: string): Promise<void>;
    disconnect(chainName: string): Promise<void>;
    refreshRouting(chainNames?: readonly string[]): Promise<Map<string, string>>;
    routingTable(): Promise<Map<string, string>>;
    supportedGenesisHashes(): Promise<Uint8Array[]>;
    routeChainByGenesisHash(genesisHash: Uint8Array): Promise<string | null>;
    sendRpc(chainName: string, method: string, paramsJson: string): Promise<string>;
    startSubscription(chainName: string, method: string, paramsJson: string, onMessage: (jsonRpc: string) => void, onAbort: (reason: string) => void): Promise<() => Promise<void>>;
    destroy(): Promise<void>;
}
/**
 * Serve a HostRuntime over a MessagePort-compatible transport.
 *
 * This is the runtime-frame side of the common-origin iframe pattern.
 */
export declare function serveHostRuntimePort(port: HostRuntimePort, runtime: HostRuntime, chainService?: RuntimeChainService<string> | null): () => void;
/**
 * Connect to a HostRuntime that is already exposed over a MessagePort.
 */
export declare function connectHostRuntimePort(port: HostRuntimePort): RemoteHostRuntime;
export declare function connectHostRuntimeFramePort(port: HostRuntimePort, hasChainService: boolean): {
    runtime: RemoteHostRuntime;
    chainService: RemoteRuntimeChainService | null;
};
export interface InstallHostRuntimeFrameOptions {
    sdk: HostRuntimeConstructorArg;
    scopeId?: string;
    registry?: HostRuntimeRegistry;
    trustedParentOrigin: TrustedOriginMatcher;
    createRuntime?: () => HostRuntime;
    createChainService?: () => RuntimeChainService<string> | Promise<RuntimeChainService<string> | null> | null;
}
/**
 * Install the runtime-frame server inside a trusted common-origin iframe page.
 *
 * The host page should create the iframe, then call `mountHostRuntimeFrame()`
 * to transfer a MessagePort into it. Instantiate host-owned browser services
 * like SmoldotDriver in this page to keep cache/storage scoped to the shared
 * runtime origin.
 */
export declare function installHostRuntimeFrame(options: InstallHostRuntimeFrameOptions): () => void;
export interface MountHostRuntimeFrameOptions {
    runtimeUrl: string;
    runtimeOrigin: string;
    parent?: HTMLElement;
    scopeId?: string;
    timeoutMs?: number;
    iframeAttributes?: Record<string, string>;
}
export interface HostRuntimeFrameHandle {
    readonly iframe: HTMLIFrameElement;
    readonly runtime: RemoteHostRuntime;
    readonly chainService: RemoteRuntimeChainService | null;
    destroy(): void;
}
/**
 * Mount a hidden trusted runtime iframe and connect to its HostRuntime server.
 *
 * The iframe should be served from a common host-controlled origin, such as
 * `https://host.dot.li/runtime-frame.html`, so host-owned browser services can
 * live behind one trusted runtime boundary. Note that modern browsers may still
 * partition iframe storage by top-level site; hosts that need unpartitioned
 * durable cache reuse across pages must account for those browser policies.
 */
export declare function mountHostRuntimeFrame(options: MountHostRuntimeFrameOptions): Promise<HostRuntimeFrameHandle>;
export {};
//# sourceMappingURL=host-runtime-frame.d.ts.map