import { Context, Effect, Layer } from 'effect';
import type { PipelineConfigV2 } from './pipeline';
import type { PipelineResult } from './executor';
import { type GraphWorkflowConfig } from './graph';
import type { GraphExecutionResult } from './graph-executor';
import type { GraphWorkflowBuilder } from './graph-builder';
import type { ResumeOptions, ResumeResult } from './resume';
import type { HumanInputResumeOptions } from './pause/types';
import { PipelineNotFoundError, PipelineAlreadyExistsError, PipelineExecutionError, GraphValidationError, type ResumeError } from './errors';
import { AgentService } from '../agent/service';
import { HookManagerService } from '../hooks/service';
import { CheckpointService } from './checkpoint/service';
import { PauseService } from './pause/service';
import { ExecutorService } from './executor';
import { GraphExecutorService } from './graph-executor';
import { type CompilableWorkflow } from '../workflow/compile';
import type { WorkflowIR } from '../workflow/ir';
import { type WorkflowDescriptor } from '../workflow/contracts';
/**
 * PipelineService interface for Effect-based pipeline management
 */
export interface PipelineService {
    /** Clear all registered V2, graph, and native workflows. */
    clear(): Effect.Effect<void>;
    /** Register any workflow dialect through the single IR compile path. */
    defineWorkflow(config: CompilableWorkflow): Effect.Effect<void, PipelineAlreadyExistsError | PipelineExecutionError | GraphValidationError>;
    /** Get the canonical compiled representation for any registered workflow. */
    getWorkflowIR(id: string): Effect.Effect<WorkflowIR, PipelineNotFoundError>;
    /** List immutable transport-neutral descriptors from the canonical registry. */
    listWorkflows(): Effect.Effect<readonly WorkflowDescriptor[]>;
    /** Describe one registered workflow without exposing its executable IR. */
    describeWorkflow(id: string): Effect.Effect<WorkflowDescriptor, PipelineNotFoundError>;
    /** Check the unified workflow registry. */
    hasWorkflowIR(id: string): Effect.Effect<boolean>;
    /**
     * Create a V2 pipeline from configuration
     */
    createPipelineV2(config: PipelineConfigV2): Effect.Effect<void, PipelineAlreadyExistsError | PipelineExecutionError>;
    /**
     * Get a V2 pipeline by ID
     */
    getPipelineV2(id: string): Effect.Effect<PipelineConfigV2, PipelineNotFoundError>;
    /**
     * Check if a V2 pipeline exists
     */
    hasPipelineV2(id: string): Effect.Effect<boolean>;
    /**
     * Get all V2 pipelines
     */
    getAllPipelinesV2(): Effect.Effect<PipelineConfigV2[]>;
    /**
     * Execute a V2 pipeline
     */
    executePipelineV2(pipelineId: string, input: string, options?: {
        conversationId?: string;
        history?: Array<{
            role: string;
            content: string;
        }>;
    }): Effect.Effect<PipelineResult, PipelineExecutionError>;
    /**
     * Resume a V2 pipeline from a checkpoint.
     * Restores checkpoint state as source of truth and continues execution.
     */
    resume(runId: string, options?: ResumeOptions): Effect.Effect<ResumeResult, ResumeError | PipelineExecutionError>;
    /**
     * Resume a paused V2 pipeline with human input.
     * Only unblocks paused checkpoints and preserves non-input checkpoint state.
     */
    resumeWithHumanInput(runId: string, options: HumanInputResumeOptions): Effect.Effect<ResumeResult, ResumeError | PipelineExecutionError>;
    /**
     * Register a graph workflow configuration
     */
    registerGraphWorkflow(config: GraphWorkflowConfig): Effect.Effect<void, GraphValidationError>;
    /**
     * Get a graph workflow by ID
     */
    getGraphWorkflow(id: string): Effect.Effect<GraphWorkflowConfig, PipelineNotFoundError>;
    /**
     * Check if a graph workflow exists
     */
    hasGraphWorkflow(id: string): Effect.Effect<boolean>;
    /**
     * Get all graph workflows
     */
    getAllGraphWorkflows(): Effect.Effect<GraphWorkflowConfig[]>;
    /**
     * Execute a graph workflow with structured concurrency
     * Fork nodes create parallel fibers, join nodes collect results
     */
    executeGraphWorkflow(id: string, input: string, options?: {
        conversationId?: string;
    }): Effect.Effect<GraphExecutionResult, PipelineExecutionError>;
    /**
     * Create a graph workflow from a builder and register it
     */
    createGraphWorkflowFromBuilder(builder: GraphWorkflowBuilder): Effect.Effect<GraphWorkflowConfig, GraphValidationError>;
    /**
     * Get the pause service for direct access
     */
    getPauseService(): Effect.Effect<PauseService>;
}
export declare const PipelineService: Context.Tag<PipelineService, PipelineService>;
/**
 * Live layer providing PipelineService
 * Requires AgentService, HookManagerService, CheckpointService, PauseService
 */
export declare const PipelineServiceLive: Layer.Layer<PipelineService, never, ExecutorService | GraphExecutorService | HookManagerService | AgentService | CheckpointService | PauseService>;
//# sourceMappingURL=service.d.ts.map