import type { CinemaProductionQueueArtifact, CinemaQueueMoney, CinemaQueuePayload, CinemaQueueTask, CinemaQueueTaskKind } from './cinema-queue-types.js';
import type { CinemaSpendAuthorizationPort } from './cinema-provider-types.js';
import type { CinemaProviderContractBundle } from './cinema-provider-types.js';
import type { AcquireResult, LaneCooldown, LaneCooldownReason, LaneStatus } from './lane-queue.js';
export interface CinemaLaneQueuePort {
    acquire(params: {
        lane: string;
        project: string;
        scene?: number | null;
        promptHash?: string | null;
        limit: number | null;
        ttlSec?: number;
        holder?: string;
    }): AcquireResult;
    status(lane: string, limit?: number | null): LaneStatus;
    heartbeat(ticketId: string, ttlSec?: number): boolean;
    release(ticketId: string, lane?: string, limit?: number | null): void;
    /**
     * Pause the render queue for every computer (a provider human check). Optional,
     * like the real coordinator's: a port without it is reported as a warning, never
     * an error. Only a HELD ticket may report one — so call it before `release`.
     */
    cooldown?(ticketId: string, lane: string, reasonCode: LaneCooldownReason, retryAfterSeconds: number): LaneCooldown;
}
/** Where a provider human check is reported from, and how it is announced. */
export interface CinemaHumanCheckOptions {
    /** Read for `VCLAW_PROVIDER_HUMAN_CHECK_COOLDOWN_SECONDS`. Default: `process.env`. */
    env?: NodeJS.ProcessEnv;
    /** One line when a pause was recorded or could not be. Default: stderr. */
    log?: (line: string) => void;
}
export interface EnqueueCinemaTaskInput {
    taskId: string;
    kind: CinemaQueueTaskKind;
    payload: CinemaQueuePayload;
    dependencies?: string[];
    routeId: string;
    shotId?: string;
    attemptId?: string;
    lane?: {
        laneId: string;
        limit: number | null;
    } | null;
    estimatedCost?: CinemaQueueMoney;
    authorizationRequirement?: 'none' | 'exact-quote';
    spendAuthorizationId?: string | null;
    createdAt?: string;
}
export interface CinemaQueueMutationResult {
    queue: CinemaProductionQueueArtifact;
    task: CinemaQueueTask;
}
export interface CinemaQueueEnqueueResult extends CinemaQueueMutationResult {
    enqueued: boolean;
}
export interface CinemaQueueClaimResult {
    queue: CinemaProductionQueueArtifact;
    task: CinemaQueueTask | null;
    disposition: 'leased' | 'waiting-lane' | 'empty';
}
export interface CinemaQueueAuthorizationBindingResult {
    queue: CinemaProductionQueueArtifact;
    tasks: CinemaQueueTask[];
}
export interface CinemaProviderReconciliationPort {
    lookup(input: {
        routeId: string;
        submissionKey: string;
        providerJobId: string | null;
    }): Promise<{
        state: 'not-found' | 'accepted' | 'processing' | 'completed' | 'failed' | 'unknown';
        authoritative: boolean;
        providerJobId: string | null;
        providerStatus: string;
        envelope: Record<string, unknown>;
        failure?: {
            code: string;
            message: string;
            retryable: boolean;
        };
    }>;
}
export declare function cinemaProductionQueuePathFor(root: string, projectSlug: string): string;
export declare function readCinemaProductionQueue(root: string, projectSlug: string): Promise<CinemaProductionQueueArtifact | null>;
export declare function enqueueCinemaTask(root: string, projectSlug: string, input: EnqueueCinemaTaskInput): Promise<CinemaQueueEnqueueResult>;
export declare function bindCinemaQuotedAuthorization(root: string, projectSlug: string, input: {
    bundle: CinemaProviderContractBundle;
    now?: string;
    /**
     * Authorization ids the caller has verified as stale (their quote,
     * authorization or capability snapshot expired before `now`). A task still
     * bound to one of them, never submitted, never leased and with no recorded
     * spend, may rebind to this authorization: the earlier one can no longer be
     * executed under, so the operator's only path is a fresh quote (#542).
     * Anything else that binds a different authorization is refused as before.
     */
    staleAuthorizationIds?: ReadonlySet<string>;
}): Promise<CinemaQueueAuthorizationBindingResult>;
export declare function beginCinemaTaskSubmission(root: string, projectSlug: string, input: {
    taskId: string;
    leaseId: string;
    now?: string;
}): Promise<CinemaQueueMutationResult>;
export declare function recordCinemaTaskSubmitted(root: string, projectSlug: string, input: {
    taskId: string;
    leaseId: string;
    providerJobId: string;
    providerStatus: string;
    envelope: Record<string, unknown>;
    now?: string;
}): Promise<CinemaQueueMutationResult>;
export declare function markCinemaTaskSubmissionUnknown(root: string, projectSlug: string, input: {
    taskId: string;
    leaseId: string;
    reason: string;
    envelope?: Record<string, unknown>;
    laneQueue?: CinemaLaneQueuePort;
    now?: string;
} & CinemaHumanCheckOptions): Promise<CinemaQueueMutationResult>;
export declare function reconcileCinemaProviderTask(root: string, projectSlug: string, input: {
    taskId: string;
    leaseId: string;
    port: CinemaProviderReconciliationPort;
    laneQueue?: CinemaLaneQueuePort;
    now?: string;
} & CinemaHumanCheckOptions): Promise<CinemaQueueMutationResult>;
export declare function recordCinemaTaskDownloadStarted(root: string, projectSlug: string, input: {
    taskId: string;
    leaseId: string;
    temporaryPath: string;
    now?: string;
}): Promise<CinemaQueueMutationResult>;
export declare function completeCinemaTaskDownload(root: string, projectSlug: string, input: {
    taskId: string;
    leaseId: string;
    finalPath: string;
    evidenceIds: string[];
    actualCost?: CinemaQueueMoney;
    spendAuthorization?: CinemaSpendAuthorizationPort;
    laneQueue?: CinemaLaneQueuePort;
    now?: string;
}): Promise<CinemaQueueMutationResult>;
export declare function claimCinemaTask(root: string, projectSlug: string, options: {
    workerId: string;
    laneQueue?: CinemaLaneQueuePort;
    spendAuthorization?: CinemaSpendAuthorizationPort;
    now?: string;
    leaseSeconds?: number;
    taskId?: string;
}): Promise<CinemaQueueClaimResult>;
export declare function completeCinemaTask(root: string, projectSlug: string, input: {
    taskId: string;
    leaseId: string;
    evidenceIds: string[];
    actualCost?: CinemaQueueMoney;
    laneQueue?: CinemaLaneQueuePort;
    spendAuthorization?: CinemaSpendAuthorizationPort;
    now?: string;
}): Promise<CinemaQueueMutationResult>;
export declare function failCinemaTask(root: string, projectSlug: string, input: {
    taskId: string;
    leaseId: string;
    failure: NonNullable<CinemaQueueTask['failure']>;
    evidenceIds?: string[];
    laneQueue?: CinemaLaneQueuePort;
    now?: string;
} & CinemaHumanCheckOptions): Promise<CinemaQueueMutationResult>;
/**
 * Cancel only untouched descendants of a dead-letter chain task after their
 * immutable replacement tail has been enqueued. Idempotent for the same
 * transition; refuses any task that has begun provider or local execution.
 */
export declare function cancelCinemaChainFallbackTail(root: string, projectSlug: string, input: {
    taskIds: string[];
    transitionId: string;
    replacementTaskIds: string[];
    evidenceId: string;
    now?: string;
}): Promise<CinemaProductionQueueArtifact>;
export declare function heartbeatCinemaTask(root: string, projectSlug: string, input: {
    taskId: string;
    leaseId: string;
    laneQueue?: CinemaLaneQueuePort;
    now?: string;
    leaseSeconds?: number;
}): Promise<CinemaQueueMutationResult>;
export declare function handoffCinemaTaskLease(root: string, projectSlug: string, input: {
    taskId: string;
    leaseId: string;
    now?: string;
}): Promise<CinemaQueueMutationResult>;
//# sourceMappingURL=cinema-production-queue.d.ts.map