import { j as AICallLogger, k as CreateAICallInput, l as AIHelperStats, m as AICallRecord, J as JobQueue, E as EnqueueJobInput, D as DequeueResult, n as JobRecord, o as JobStatus, 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, h as CreateOutboxEventInput, O as OutboxRecord, s as SaveArtifactInput, t as WorkflowArtifactRecord, f as CreateAnnotationInput, A as AnnotationFilters, g as WorkflowAnnotationRecord, u as WorkflowLogRecord } from '../interface-DMzwv0lD.js';

/**
 * In-Memory AI Call Logger
 *
 * A complete in-memory implementation of AICallLogger for testing.
 * Tracks all AI calls with full cost/token tracking and topic-based aggregation.
 *
 * @example
 * ```typescript
 * import { InMemoryAICallLogger } from '@bratsos/workflow-engine/testing';
 *
 * const aiLogger = new InMemoryAICallLogger();
 * // Use in tests...
 * aiLogger.clear(); // Reset between tests
 * ```
 */

declare class InMemoryAICallLogger implements AICallLogger {
    private calls;
    private recordedBatches;
    /**
     * Log a single AI call (fire and forget)
     */
    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>;
    /**
     * Clear all data - useful between tests
     */
    clear(): void;
    /**
     * Get all calls for inspection
     */
    getAllCalls(): AICallRecord[];
    /**
     * Get calls by topic for inspection
     */
    getCallsByTopic(topic: string): AICallRecord[];
    /**
     * Get calls by topic prefix for inspection
     */
    getCallsByTopicPrefix(prefix: string): AICallRecord[];
    /**
     * Get calls by model for inspection
     */
    getCallsByModel(modelKey: string): AICallRecord[];
    /**
     * Get calls by call type for inspection
     */
    getCallsByType(callType: string): AICallRecord[];
    /**
     * Get total cost across all calls
     */
    getTotalCost(): number;
    /**
     * Get total tokens across all calls
     */
    getTotalTokens(): {
        input: number;
        output: number;
    };
    /**
     * Get call count
     */
    getCallCount(): number;
    /**
     * Get all recorded batch IDs
     */
    getRecordedBatchIds(): string[];
    /**
     * Get the last call made (useful for assertions)
     */
    getLastCall(): AICallRecord | null;
    /**
     * Assert a call was made with specific properties
     */
    hasCallMatching(predicate: (call: AICallRecord) => boolean): boolean;
}

/**
 * In-Memory Job Queue
 *
 * A complete in-memory implementation of JobQueue for testing.
 * Supports priority ordering, locking, and stale job recovery.
 *
 * @example
 * ```typescript
 * import { InMemoryJobQueue } from '@bratsos/workflow-engine/testing';
 *
 * const jobQueue = new InMemoryJobQueue();
 * // Use in tests...
 * jobQueue.clear(); // Reset between tests
 * ```
 */

declare class InMemoryJobQueue implements JobQueue {
    private jobs;
    private workerId;
    private defaultMaxAttempts;
    constructor(workerId?: string);
    enqueue(options: EnqueueJobInput): Promise<string>;
    enqueueParallel(jobs: EnqueueJobInput[]): Promise<string[]>;
    dequeue(): Promise<DequeueResult | null>;
    complete(jobId: string): Promise<void>;
    suspend(jobId: string, nextPollAt: Date): Promise<void>;
    fail(jobId: string, error: string, shouldRetry?: boolean): Promise<void>;
    getSuspendedJobsReadyToPoll(): Promise<Array<{
        jobId: string;
        stageId: string;
        workflowRunId: string;
    }>>;
    releaseStaleJobs(staleThresholdMs?: number): Promise<number>;
    cancelByRun(workflowRunId: string): Promise<number>;
    /**
     * Clear all jobs - useful between tests
     */
    clear(): void;
    /**
     * Get all jobs for inspection
     */
    getAllJobs(): JobRecord[];
    /**
     * Get jobs by status for inspection
     */
    getJobsByStatus(status: JobStatus): JobRecord[];
    /**
     * Get a specific job by ID
     */
    getJob(jobId: string): JobRecord | null;
    /**
     * Get the worker ID for this queue instance
     */
    getWorkerId(): string;
    /**
     * Set max attempts for new jobs
     */
    setDefaultMaxAttempts(maxAttempts: number): void;
    /**
     * Simulate a worker crash by releasing a job's lock without completing it
     */
    simulateCrash(jobId: string): void;
    /**
     * Move a suspended job back to pending (for manual resume testing)
     */
    resumeJob(jobId: string): void;
    /**
     * Set lockedAt for testing stale job scenarios
     */
    setJobLockedAt(jobId: string, lockedAt: Date): void;
    /**
     * Set nextPollAt for testing suspended job polling
     */
    setJobNextPollAt(jobId: string, nextPollAt: Date | null): void;
}

/**
 * In-Memory Workflow Persistence
 *
 * A complete in-memory implementation of WorkflowPersistence for testing.
 * All data is stored in Maps and lost when the instance is garbage collected.
 *
 * @example
 * ```typescript
 * import { InMemoryWorkflowPersistence } from '@bratsos/workflow-engine/testing';
 *
 * const persistence = new InMemoryWorkflowPersistence();
 * // Use in tests...
 * persistence.clear(); // Reset between tests
 * ```
 */

declare class InMemoryWorkflowPersistence implements WorkflowPersistence {
    private runs;
    private stages;
    private logs;
    private artifacts;
    private annotations;
    private outbox;
    private idempotencyKeys;
    private idempotencyInProgress;
    private outboxSequences;
    private stageKey;
    private artifactKey;
    private idempotencyCompositeKey;
    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>;
    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>;
    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>;
    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>;
    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[]>;
    saveStageOutput(runId: string, workflowType: string, stageId: string, output: unknown): Promise<string>;
    /**
     * Clear all data - useful between tests
     */
    clear(): void;
    /**
     * Get all runs for inspection
     */
    getAllRuns(): WorkflowRunRecord[];
    /**
     * Get all stages for inspection
     */
    getAllStages(): WorkflowStageRecord[];
    /**
     * Get all logs for inspection
     */
    getAllLogs(): WorkflowLogRecord[];
    /**
     * Get all artifacts for inspection
     */
    getAllArtifacts(): WorkflowArtifactRecord[];
    /**
     * Get all annotations for inspection
     */
    getAllAnnotations(): WorkflowAnnotationRecord[];
}

export { InMemoryAICallLogger, InMemoryJobQueue, InMemoryWorkflowPersistence };