import type { CommandReceipt, ManagedReadResult, WaitingReceipt, ManagedCommandMinePage } from 'openxiangda-contracts/browser';
export interface ManagedReadRecoveryOptions {
    /**
     * 含请求与繁忙退避的本调用总预算，默认 120 秒 / 12 次请求。
     * 显式超过 120 秒时最多 30 分钟 / 120 次请求，超过上限按 30 分钟处理。
     * 仅恢复已知只读繁忙；不会延长已提交申请的受理或观察期限。
     */
    budgetMs?: number;
}
export interface ManagedConcurrencyClient {
    /** Bound to the current application, environment and trusted user. */
    readonly scope: string;
    read<T = Record<string, unknown>>(code: string, input: Record<string, unknown>, signal?: AbortSignal, recovery?: ManagedReadRecoveryOptions): Promise<ManagedReadResult<T>>;
    enqueue(command: string, input: Record<string, unknown>, requestKey: string, signal?: AbortSignal): Promise<CommandReceipt>;
    mine(command: string, input: {
        resourceKey: string;
        cursor?: string;
        limit?: number;
    }, signal?: AbortSignal, recovery?: ManagedReadRecoveryOptions): Promise<ManagedCommandMinePage>;
    join(command: string, input: Record<string, unknown>, requestKey: string, signal?: AbortSignal): Promise<WaitingReceipt>;
    poll(ticket: string, signal?: AbortSignal): Promise<WaitingReceipt>;
    leave(ticket: string, signal?: AbortSignal): Promise<{
        state: 'cancelled' | 'accepted';
        requestKey: string;
    }>;
    accept(permit: string, signal?: AbortSignal): Promise<CommandReceipt>;
    result(input: {
        operationId: string;
    } | {
        command: string;
        requestKey: string;
    }, signal?: AbortSignal, recovery?: ManagedReadRecoveryOptions): Promise<CommandReceipt>;
    cancel(operationId: string, signal?: AbortSignal): Promise<CommandReceipt>;
    allocation(allocationId: string, signal?: AbortSignal, recovery?: ManagedReadRecoveryOptions): Promise<NonNullable<NonNullable<CommandReceipt['result']>['allocation']>>;
}
export interface ManagedCommandSnapshot {
    state: 'idle' | 'waiting' | 'admitted' | 'recovering' | 'error' | CommandReceipt['state'];
    requestKey?: string;
    waiting?: WaitingReceipt;
    receipt?: CommandReceipt;
    errorCode?: string;
}
/** One durable request key per UI intent. Stopping the observer never cancels an accepted command. */
export declare class ManagedCommandController {
    private readonly options;
    private value;
    private readonly listeners;
    private recovery?;
    private abort?;
    private running?;
    private cancelling?;
    private submitRequested;
    private generation;
    private readonly key;
    private readonly input;
    constructor(options: {
        client: ManagedConcurrencyClient;
        command: string;
        input: Record<string, unknown>;
        /** Stable name for this screen's operation, e.g. the selected resource ID. */
        storageKey: string;
        storage: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
        autoAccept?: boolean;
        sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
        random?: () => number;
    });
    snapshot: () => ManagedCommandSnapshot;
    subscribe: (listener: () => void) => () => void;
    private update;
    private persist;
    private restore;
    /** Resume an existing intent without starting a new one on page mount. */
    resume(): Promise<void>;
    start(requestKey?: string): Promise<void>;
    submit(): Promise<void>;
    stop(): void;
    /** Explicitly begin a different intent only after a known terminal receipt. */
    clear(): void;
    cancel(): Promise<void>;
    private cancelOriginal;
    private findOriginal;
    private run;
    private observe;
    private pollDelay;
}
//# sourceMappingURL=managed-command.d.ts.map