import { j as AICallLogger, k as CreateAICallInput, l as AIHelperStats, p as WorkflowPersistence, C as CreateRunInput, W as WorkflowRunRecord, U as UpdateRunInput, q as WorkflowStatus, a as CreateStageInput, b as WorkflowStageRecord, c as UpsertStageInput, d as UpdateStageInput, r as WorkflowStageStatus, e as CreateLogInput, s as SaveArtifactInput, t as WorkflowArtifactRecord, f as CreateAnnotationInput, A as AnnotationFilters, g as WorkflowAnnotationRecord, h as CreateOutboxEventInput, O as OutboxRecord, J as JobQueue, E as EnqueueJobInput, D as DequeueResult } from './interface-DMzwv0lD.js';

/**
 * PrismaAICallLogger - Prisma implementation of AICallLogger
 *
 * Handles AI call logging to the database. Uses fire-and-forget pattern
 * for non-blocking logging during AI operations.
 */

type PrismaClient$2 = any;
declare class PrismaAICallLogger implements AICallLogger {
    private readonly prisma;
    constructor(prisma: PrismaClient$2);
    /**
     * Log a single AI call (fire and forget)
     * Does not await - logs asynchronously to avoid blocking AI operations
     */
    logCall(call: CreateAICallInput): void;
    /**
     * Log batch results (for recording batch API results)
     */
    logBatchResults(batchId: string, results: CreateAICallInput[]): Promise<void>;
    /**
     * Get aggregated stats for a topic prefix
     */
    getStats(topicPrefix: string): Promise<AIHelperStats>;
    /**
     * Check if batch results are already recorded
     */
    isRecorded(batchId: string): Promise<boolean>;
}
declare function createPrismaAICallLogger(prisma: PrismaClient$2): AICallLogger;

/**
 * PrismaWorkflowPersistence - Prisma implementation of WorkflowPersistence
 *
 * This is the default persistence implementation used by the workflow engine.
 * It wraps Prisma client operations to match the WorkflowPersistence interface.
 */

type PrismaClient$1 = any;
type DatabaseType = "postgresql" | "sqlite";
interface PrismaWorkflowPersistenceOptions {
    /**
     * Database type. Defaults to "postgresql".
     * Set to "sqlite" when using SQLite (uses optimistic locking instead of FOR UPDATE SKIP LOCKED).
     */
    databaseType?: DatabaseType;
    /**
     * Skip interactive transactions. Defaults to false.
     * Set to true in single-process environments where transactions are not needed.
     */
    skipInteractiveTransactions?: boolean;
}
declare class PrismaWorkflowPersistence implements WorkflowPersistence {
    private readonly prisma;
    private enums;
    private databaseType;
    private skipTransactions;
    constructor(prisma: PrismaClient$1, options?: PrismaWorkflowPersistenceOptions);
    withTransaction<T>(fn: (tx: WorkflowPersistence) => Promise<T>): Promise<T>;
    createRun(data: CreateRunInput): Promise<WorkflowRunRecord>;
    updateRun(id: string, data: UpdateRunInput): Promise<void>;
    getRun(id: string): Promise<WorkflowRunRecord | null>;
    getRunStatus(id: string): Promise<WorkflowStatus | null>;
    getRunsByStatus(status: WorkflowStatus): Promise<WorkflowRunRecord[]>;
    getStuckRuns(stuckSince: Date): Promise<WorkflowRunRecord[]>;
    claimPendingRun(id: string): Promise<boolean>;
    claimNextPendingRun(): Promise<WorkflowRunRecord | null>;
    /**
     * PostgreSQL implementation using FOR UPDATE SKIP LOCKED for zero-contention claiming.
     * This atomically:
     * 1. Finds the highest priority PENDING run (FIFO within same priority)
     * 2. Locks it exclusively (other workers skip locked rows)
     * 3. Updates it to RUNNING
     * 4. Returns the claimed run
     */
    private claimNextPendingRunPostgres;
    /**
     * SQLite implementation using optimistic locking.
     * SQLite doesn't support FOR UPDATE SKIP LOCKED, so we use a two-step approach:
     * 1. Find a PENDING run
     * 2. Atomically update it (only succeeds if still PENDING)
     * 3. If another worker claimed it, retry
     */
    private claimNextPendingRunSqlite;
    createStage(data: CreateStageInput): Promise<WorkflowStageRecord>;
    upsertStage(data: UpsertStageInput): Promise<WorkflowStageRecord>;
    updateStage(id: string, data: UpdateStageInput): Promise<void>;
    updateStageByRunAndStageId(workflowRunId: string, stageId: string, data: UpdateStageInput): Promise<void>;
    private buildRunUpdateData;
    private buildStageUpdateData;
    getStage(runId: string, stageId: string): Promise<WorkflowStageRecord | null>;
    getStageById(id: string): Promise<WorkflowStageRecord | null>;
    getStagesByRun(runId: string, options?: {
        status?: WorkflowStageStatus;
        orderBy?: "asc" | "desc";
    }): Promise<WorkflowStageRecord[]>;
    getSuspendedStages(beforeDate: Date): Promise<WorkflowStageRecord[]>;
    getFirstSuspendedStageReadyToResume(runId: string): Promise<WorkflowStageRecord | null>;
    getFirstFailedStage(runId: string): Promise<WorkflowStageRecord | null>;
    getLastCompletedStage(runId: string): Promise<WorkflowStageRecord | null>;
    getLastCompletedStageBefore(runId: string, executionGroup: number): Promise<WorkflowStageRecord | null>;
    deleteStage(id: string): Promise<void>;
    createLog(data: CreateLogInput): Promise<void>;
    saveArtifact(data: SaveArtifactInput): Promise<void>;
    loadArtifact(runId: string, key: string): Promise<unknown>;
    hasArtifact(runId: string, key: string): Promise<boolean>;
    deleteArtifact(runId: string, key: string): Promise<void>;
    listArtifacts(runId: string): Promise<WorkflowArtifactRecord[]>;
    getStageIdForArtifact(runId: string, stageId: string): Promise<string | null>;
    appendAnnotations(inputs: CreateAnnotationInput[]): Promise<void>;
    listAnnotations(workflowRunId: string, filters?: AnnotationFilters): Promise<WorkflowAnnotationRecord[]>;
    private mapWorkflowAnnotation;
    saveStageOutput(runId: string, workflowType: string, stageId: string, output: unknown): Promise<string>;
    appendOutboxEvents(events: CreateOutboxEventInput[]): Promise<void>;
    getUnpublishedOutboxEvents(limit?: number): Promise<OutboxRecord[]>;
    markOutboxEventsPublished(ids: string[]): Promise<void>;
    incrementOutboxRetryCount(id: string): Promise<number>;
    moveOutboxEventToDLQ(id: string): Promise<void>;
    replayDLQEvents(maxEvents: number): Promise<number>;
    acquireIdempotencyKey(key: string, commandType: string): Promise<{
        status: "acquired";
    } | {
        status: "replay";
        result: unknown;
    } | {
        status: "in_progress";
    }>;
    completeIdempotencyKey(key: string, commandType: string, result: unknown): Promise<void>;
    releaseIdempotencyKey(key: string, commandType: string): Promise<void>;
    private mapWorkflowRun;
    private mapWorkflowStage;
    private mapOutboxEvent;
    private mapWorkflowArtifact;
}
/**
 * Factory function to create PrismaWorkflowPersistence
 */
declare function createPrismaWorkflowPersistence(prisma: PrismaClient$1, options?: PrismaWorkflowPersistenceOptions): PrismaWorkflowPersistence;

/**
 * PrismaJobQueue - Prisma implementation of JobQueue
 *
 * Provides atomic job queue operations using PostgreSQL
 * with FOR UPDATE SKIP LOCKED for safe concurrent access.
 *
 * This is migrated from the original services/job-queue.server.ts
 */

type PrismaClient = any;
interface PrismaJobQueueOptions {
    /**
     * Unique worker identifier. Defaults to auto-generated ID.
     */
    workerId?: string;
    /**
     * Database type. Defaults to "postgresql".
     * Set to "sqlite" when using SQLite (uses optimistic locking instead of FOR UPDATE SKIP LOCKED).
     */
    databaseType?: DatabaseType;
}
declare class PrismaJobQueue implements JobQueue {
    private workerId;
    private prisma;
    private enums;
    private databaseType;
    constructor(prisma: PrismaClient, options?: PrismaJobQueueOptions);
    /**
     * Add a new job to the queue
     */
    enqueue(options: EnqueueJobInput): Promise<string>;
    /**
     * Enqueue multiple stages in parallel (same execution group)
     */
    enqueueParallel(jobs: EnqueueJobInput[]): Promise<string[]>;
    /**
     * Atomically dequeue the next available job
     * Uses FOR UPDATE SKIP LOCKED (PostgreSQL) or optimistic locking (SQLite)
     */
    dequeue(): Promise<DequeueResult | null>;
    /**
     * PostgreSQL implementation using FOR UPDATE SKIP LOCKED for safe concurrency
     */
    private dequeuePostgres;
    /**
     * SQLite implementation using optimistic locking.
     * SQLite doesn't support FOR UPDATE SKIP LOCKED, so we use a two-step approach:
     * 1. Find a PENDING job
     * 2. Atomically update it (only succeeds if still PENDING)
     * 3. If another worker claimed it, retry
     */
    private dequeueSqlite;
    /**
     * Mark job as completed
     */
    complete(jobId: string): Promise<void>;
    /**
     * Mark job as suspended (for async-batch)
     */
    suspend(jobId: string, nextPollAt: Date): Promise<void>;
    /**
     * Mark job as failed
     */
    fail(jobId: string, error: string, shouldRetry?: boolean): Promise<void>;
    /**
     * Get suspended jobs that are ready to be checked
     */
    getSuspendedJobsReadyToPoll(): Promise<Array<{
        jobId: string;
        stageId: string;
        workflowRunId: string;
    }>>;
    /**
     * Cancel all pending/suspended jobs for a workflow run.
     */
    cancelByRun(workflowRunId: string): Promise<number>;
    /**
     * Release stale locks (for crashed workers)
     */
    releaseStaleJobs(staleThresholdMs?: number): Promise<number>;
}
/**
 * Factory function to create PrismaJobQueue with prisma client
 *
 * @param prisma - Prisma client instance
 * @param optionsOrWorkerId - Options object or workerId string (for backwards compatibility)
 */
declare function createPrismaJobQueue(prisma: PrismaClient, optionsOrWorkerId?: PrismaJobQueueOptions | string): JobQueue;

export { type DatabaseType as D, PrismaAICallLogger as P, PrismaJobQueue as a, type PrismaJobQueueOptions as b, PrismaWorkflowPersistence as c, type PrismaWorkflowPersistenceOptions as d, createPrismaAICallLogger as e, createPrismaJobQueue as f, createPrismaWorkflowPersistence as g };