/** Host-owned first-pass jobs: durable submission identity, recovery and native clip adoption. */
import { type ContinuityServices } from "./video-continuity.ts";
import { type VideoPlanOptions } from "./video-generation-plan.ts";
import { type CrocoProjectState } from "./preproduction-workspace.ts";
import { type CharacterEntry } from "./providers.ts";
import type { VideoArtifact, VideoGenerationRun, VideoMedia, VideoProduction } from "./video-production-state.ts";
export interface VideoGenerationServices {
    adopt?(projectFolder: string, run: VideoGenerationRun, artifact: VideoArtifact, state: CrocoProjectState, signal: AbortSignal): Promise<{
        elementId: string;
        commit(): Promise<void>;
        rollback(): Promise<void>;
    }>;
    continuity?: ContinuityServices;
    credentials(): Promise<{
        baseUrl: string;
        token: string;
    }>;
    characters(): Promise<CharacterEntry[]>;
    inspect(projectFolder: string, relativePath: string, signal?: AbortSignal): Promise<VideoMedia>;
    sync(projectFolder: string, run: VideoGenerationRun, artifact: VideoArtifact, state: CrocoProjectState, signal: AbortSignal): Promise<string>;
}
/** One shared semaphore bounds provider jobs across requests and projects. */
export declare class VideoJobQueue {
    private readonly concurrency;
    private readonly active;
    private readonly controller;
    private readonly pending;
    private running;
    constructor(concurrency: number);
    start(key: string, work: (signal: AbortSignal) => Promise<void>): void;
    private pump;
    isActive(key: string): boolean;
    wait(key: string): Promise<void>;
    idle(): Promise<void>;
    dispose(): Promise<void>;
}
export declare class VideoGenerationManager {
    readonly queue: VideoJobQueue;
    private readonly services;
    private readonly options;
    private readonly unitRuns;
    constructor(queue: VideoJobQueue, services: VideoGenerationServices, options: VideoPlanOptions);
    /** Adopt an existing artifact without submitting a provider job. */
    selectVersion(projectFolder: string, input: {
        unitId: string;
        artifactId: string;
        compositionPath: string;
        expectedRevision: number;
    }): Promise<import("./preproduction-workspace.ts").CrocoProjectSnapshot>;
    private planningOptions;
    /** A new request generates fresh target videos; repeating its ID reuses the same work. */
    request(projectFolder: string, input: {
        requestId: string;
        sessionId: string;
        unitIds?: string[];
        operation: "generate" | "regenerate";
        compositionPath: string;
    }): Promise<VideoProduction["requests"][number]>;
    /** Freeze ready inputs; unresolved selected dependencies remain explicit, without extra paid scope. */
    prepare(projectFolder: string, requestId: string, sessionId: string, acceptedWarningIds?: string[]): Promise<{
        requestId: string;
        runs: {
            id: string;
            requestId: string;
            sessionId: string;
            unitId: string;
            compositionPath: string;
            phase: "queued" | "running" | "completed" | "failed" | "preparing" | "prompting" | "submitting" | "downloading" | "syncing" | "interrupted" | "submission-unknown";
            createdAt: string;
            updatedAt: string;
            input: {
                unitId: string;
                fingerprint: string;
                systemPromptDigest: string;
                brief: string;
                references: {
                    kind: "image" | "audio";
                    label: string;
                    roles: string[];
                    sourcePath: string;
                    relativePath: string;
                    sha256: string;
                    mimeType: string;
                }[];
                durationSeconds: number;
                requestDurationSeconds: number;
                quality: string;
                continuity?: {
                    mode: "add-guide";
                    unitId: string;
                    artifactId: string;
                    jobId: string;
                } | {
                    mode: "tail-frame";
                    unitId: string;
                    relativePath: string;
                    sha256: string;
                    endSeconds: number;
                } | undefined;
                addGuideSourceJobId?: string | undefined;
                dependencyArtifactId?: string | undefined;
            };
            clientJobId: string;
            prompt?: {
                text: string;
                fingerprint: string;
                systemPromptDigest: string;
                source: "dsh-agent";
                sessionId: string;
                createdAt: string;
            } | undefined;
            payload?: {
                parameters: Record<string, unknown>;
                inputs: {
                    role: "reference_image" | "reference_audio";
                    asset_id: string;
                }[];
            } | undefined;
            jobId?: string | undefined;
            artifactId?: string | undefined;
            previousArtifactId?: string | undefined;
            previousImportedClip?: {
                elementId: string;
                source: string;
            } | undefined;
            progress?: number | undefined;
            message?: string | undefined;
        }[];
        waiting: {
            unitId: string;
            reason: string;
            code: "input" | "failed" | "missing" | "waiting";
            predecessorId?: string | undefined;
        }[];
        warnings: {
            id: string;
            unitId: string;
            reason: string;
            target: {
                kind: "storyboard";
            } | {
                kind: "keyframe";
                keyframeId: string;
            } | {
                kind: "entity";
                entityId: string;
            };
        }[];
    }>;
    private waitingDependency;
    private key;
    private assertInputChoice;
    private assertFresh;
    savePrompt(projectFolder: string, runId: string, sessionId: string, fingerprint: string, text: string): Promise<void>;
    start(projectFolder: string, runIds: string[], sessionId: string): Promise<void>;
    private change;
    private execute;
}