import { StateDatabase } from "../state/database.js";
import type { RunWriteAuthority } from "./store.js";
import type { CheckpointNodeDefinition, HumanDecisionChoice, HumanDecisionAudience, HumanDecisionCancellationRecord, HumanDecisionChoiceMap, HumanDecisionChannelRequest, HumanDecisionContinuationRecord, HumanDecisionDeliveryRecord, HumanDecisionPrompt, HumanDecisionRequest, HumanDecisionResponse, HumanDecisionSettlementRecord, HumanDecisionSubmission, HumanDecisionTextInput, HumanDecisionTimeout, ResolvedHumanDecision, WorkflowNodeCommon, WorkflowNodeContext } from "./types.js";
export type HumanDecisionChoiceDefinition = Omit<HumanDecisionChoice, "input"> & {
    input?: HumanDecisionTextInput;
};
export type HumanDecisionDefinition<TChoices extends HumanDecisionChoiceMap> = WorkflowNodeCommon & {
    audience: HumanDecisionAudience;
    choices: TChoices;
    request: (context: WorkflowNodeContext) => HumanDecisionPrompt | Promise<HumanDecisionPrompt>;
    onTimeout?: {
        afterMs: number;
        response: HumanDecisionResponseFor<TChoices>;
    } | ((context: WorkflowNodeContext) => {
        afterMs: number;
        response: HumanDecisionResponseFor<TChoices>;
    } | undefined | Promise<{
        afterMs: number;
        response: HumanDecisionResponseFor<TChoices>;
    } | undefined>);
};
export type HumanDecisionResponseFor<TChoices extends HumanDecisionChoiceMap> = {
    [K in keyof TChoices & string]: TChoices[K] extends {
        input: HumanDecisionTextInput;
    } ? {
        choice: K;
        input: Record<TChoices[K]["input"]["name"], string>;
    } : {
        choice: K;
    };
}[keyof TChoices & string];
export declare function textInput<const TName extends string>(options: {
    name: TName;
    prompt: string;
    minLength?: number;
    maxLength?: number;
}): HumanDecisionTextInput & {
    name: TName;
};
export declare function choice<const TChoice extends HumanDecisionChoiceDefinition>(definition: TChoice): TChoice;
export declare function defineHumanChoices<const TChoices extends HumanDecisionChoiceMap>(choices: TChoices): TChoices;
/** Build a typed verified-human gate that still executes as a checkpoint. */
export declare function humanDecision<const TChoices extends HumanDecisionChoiceMap>(definition: HumanDecisionDefinition<TChoices>): CheckpointNodeDefinition & {
    readonly __humanChoices?: TChoices;
};
export declare function humanDecisionEdge<const TChoices extends HumanDecisionChoiceMap, const TFrom extends string, const TCases extends Record<keyof TChoices & string, string>>(args: {
    from: TFrom;
    choices: TChoices;
    cases: TCases & Record<Exclude<keyof TCases, keyof TChoices>, never>;
}): {
    from: TFrom;
    switch: {
        on: "$.choice";
        cases: TCases;
    };
};
export declare function createHumanDecisionRequest(input: {
    runId: string;
    workflowName: string;
    nodeId: string;
    attemptId: string;
    contract: {
        audience: string;
        choices: HumanDecisionChoiceMap;
    };
    prompt: HumanDecisionPrompt;
    timeout?: HumanDecisionTimeout;
    createdAt?: string;
}): HumanDecisionRequest;
export declare function validateHumanDecisionResponse(request: HumanDecisionRequest, value: unknown): HumanDecisionResponse;
export declare function validateHumanDecisionSubmission(request: HumanDecisionRequest, value: HumanDecisionSubmission): HumanDecisionSubmission;
export declare function humanDecisionDatabasePath(homeDir?: string): string;
export type HumanDecisionAcceptance = {
    status: "accepted" | "adopted";
    decision: ResolvedHumanDecision;
} | {
    status: "conflict";
    decision: ResolvedHumanDecision;
};
export declare class HumanDecisionStore {
    readonly databasePath: string;
    readonly state: StateDatabase;
    private readonly ownsState;
    private readonly authorityProvider;
    constructor(databasePath?: string, options?: {
        state?: StateDatabase;
        authorityProvider?: (runId: string) => RunWriteAuthority | undefined;
        readOnly?: boolean;
    });
    close(): void;
    createRequest(request: HumanDecisionRequest): Promise<"created" | "adopted">;
    readRequest(decisionId: string): Promise<HumanDecisionRequest | null>;
    recordDelivery(request: HumanDecisionRequest | HumanDecisionChannelRequest, channel: string, value: HumanDecisionDeliveryRecord): Promise<"created" | "adopted">;
    accept(request: HumanDecisionRequest, submission: HumanDecisionSubmission): Promise<HumanDecisionAcceptance>;
    resolveTimeout(request: HumanDecisionRequest, now?: Date): Promise<HumanDecisionAcceptance>;
    listDeliveries(decisionId: string, channel: string): Promise<HumanDecisionDeliveryRecord[]>;
    recordSettlement(decisionId: string, channel: string, value: HumanDecisionSettlementRecord): Promise<"created" | "adopted">;
    listSettlements(decisionId: string, channel: string): Promise<HumanDecisionSettlementRecord[]>;
    cancel(request: HumanDecisionRequest, reason: HumanDecisionCancellationRecord["reason"]): Promise<"created" | "adopted">;
    readCancellation(decisionId: string): Promise<HumanDecisionCancellationRecord | null>;
    readResolved(decisionId: string): Promise<ResolvedHumanDecision | null>;
    recordContinuation(decisionId: string, value: HumanDecisionContinuationRecord): Promise<"created" | "adopted">;
    readContinuation(decisionId: string): Promise<HumanDecisionContinuationRecord | null>;
    markEffectApplied(decisionId: string, effectType: "decision.continue" | "decision.cancel_parent" | "decision.settle_presentations"): void;
    listRequests(): Promise<HumanDecisionRequest[]>;
    private attemptAcceptance;
    private readResolution;
    private requireStoredRequest;
    private readRequestRow;
    private readRequestFromHash;
    private requireDecisionResource;
    private bumpDecision;
    private insertDecisionEvent;
    private enqueueResolutionEffects;
    private assertRunOwner;
    private recordChannelMessage;
    private listChannelMessages;
    private ensureChannel;
    private markSubmission;
    private readContinuationRow;
}
export declare function createHumanDecisionAttemptId(): string;
export declare function canonicalJson(value: unknown): string;
export declare function digest(value: unknown): string;