import { Result } from "../common/result";
import { DomainEvent } from "../domain/domain-event";
import { SagaStatus, SagaStep } from "./saga";
export declare enum SagaOrchestrationStrategy {
    ORCHESTRATION = "orchestration",
    CHOREOGRAPHY = "choreography",
    HYBRID = "hybrid"
}
export interface SagaEvent extends DomainEvent {
    sagaId: string;
    stepId?: string;
    sagaEventType: SagaEventType;
    correlationId: string;
}
export declare enum SagaEventType {
    SAGA_STARTED = "saga.started",
    SAGA_STEP_STARTED = "saga.step.started",
    SAGA_STEP_COMPLETED = "saga.step.completed",
    SAGA_STEP_FAILED = "saga.step.failed",
    SAGA_STEP_COMPENSATED = "saga.step.compensated",
    SAGA_COMPLETED = "saga.completed",
    SAGA_FAILED = "saga.failed",
    SAGA_COMPENSATED = "saga.compensated",
    SAGA_TIMEOUT = "saga.timeout"
}
export interface SagaOrchestrationStep extends SagaStep {
    triggerEvent?: string;
    publishedEvents?: string[];
    timeout?: number;
    retryConfig?: StepRetryConfig;
    compensationTimeout?: number;
    parallel?: boolean;
    dependencies?: string[];
}
export interface StepRetryConfig {
    maxRetries: number;
    retryDelay: number;
    backoffMultiplier?: number;
    maxRetryDelay?: number;
    retryableErrors?: string[];
}
export interface SagaOrchestrationContext {
    sagaId: string;
    currentStepIndex: number;
    status: SagaStatus;
    startedAt: Date;
    completedAt?: Date;
    stepHistory: StepExecutionHistory[];
    sagaData: Record<string, unknown>;
    correlationId: string;
    parentSagaId?: string;
    childSagaIds: string[];
}
export interface StepExecutionHistory {
    stepId: string;
    startedAt: Date;
    endedAt?: Date;
    status: 'started' | 'completed' | 'failed' | 'compensated' | 'timeout';
    retryCount: number;
    error?: string;
    stepData?: Record<string, unknown>;
}
export interface SagaOrchestrator {
    startSaga(sagaDefinition: SagaDefinition, initialData?: Record<string, unknown>): Promise<Result<string>>;
    handleSagaEvent(event: SagaEvent): Promise<Result<void>>;
    getSagaContext(sagaId: string): Promise<Result<SagaOrchestrationContext>>;
    cancelSaga(sagaId: string): Promise<Result<void>>;
    getActiveSagas(): Promise<Result<string[]>>;
    getSagaStatistics(): Promise<Result<SagaStatistics>>;
}
export interface SagaDefinition {
    name: string;
    version: string;
    strategy: SagaOrchestrationStrategy;
    steps: SagaOrchestrationStep[];
    globalTimeout?: number;
    globalRetryConfig?: StepRetryConfig;
    compensationStrategy?: CompensationStrategy;
}
export declare enum CompensationStrategy {
    COMPENSATE_ALL = "compensate_all",
    COMPENSATE_FAILED_ONLY = "compensate_failed_only",
    COMPENSATE_BACKWARDS = "compensate_backwards",
    NO_COMPENSATION = "no_compensation"
}
export interface SagaStatistics {
    totalSagas: number;
    activeSagas: number;
    completedSagas: number;
    failedSagas: number;
    compensatedSagas: number;
    averageExecutionTime: number;
    successRate: number;
}
export declare abstract class BaseSagaOrchestrator implements SagaOrchestrator {
    private eventBus?;
    private activeSagas;
    private sagaDefinitions;
    private sagaStatistics;
    constructor(eventBus?: SagaEventPublisher);
    protected abstract executeStep(step: SagaOrchestrationStep, context: SagaOrchestrationContext): Promise<void>;
    startSaga(sagaDefinition: SagaDefinition, initialData?: Record<string, unknown>): Promise<Result<string>>;
    handleSagaEvent(event: SagaEvent): Promise<Result<void>>;
    getSagaContext(sagaId: string): Promise<Result<SagaOrchestrationContext>>;
    cancelSaga(sagaId: string): Promise<Result<void>>;
    getActiveSagas(): Promise<Result<string[]>>;
    getSagaStatistics(): Promise<Result<SagaStatistics>>;
    private executeNextStep;
    private handleStepCompleted;
    private handleStepFailed;
    private handleSagaTimeout;
    private completeSaga;
    private handleStepFailure;
    private handleCompensation;
    private compensateAllSteps;
    private compensateBackwards;
    private executeCompensation;
    private generateSagaId;
    private generateCorrelationId;
    private generateEventId;
}
export declare class SagaDefinitionBuilder {
    private name;
    private definition;
    constructor(name: string);
    version(version: string): SagaDefinitionBuilder;
    strategy(strategy: SagaOrchestrationStrategy): SagaDefinitionBuilder;
    addStep(step: SagaOrchestrationStep): SagaDefinitionBuilder;
    globalTimeout(timeout: number): SagaDefinitionBuilder;
    globalRetryConfig(config: StepRetryConfig): SagaDefinitionBuilder;
    compensationStrategy(strategy: CompensationStrategy): SagaDefinitionBuilder;
    build(): SagaDefinition;
}
export declare function createSagaDefinition(name: string): SagaDefinitionBuilder;
export interface SagaEventPublisher {
    publish(topic: string, event: SagaEvent): Promise<void>;
}