/**
 * Task State Orchestrator - Orchestrates state update operations
 *
 * REFACTORED: Extracted from TaskManager.updateTaskState() for Phase 3.
 * Orchestrates the entire state update flow: load → validate → update → persist → actions → context
 *
 * @internal
 * @requirement REFACTOR-EXTRACT-ORCHESTRATION-SERVICES - Phase 3: Extract orchestration services
 */
import type { WorkflowState } from '@shadel/workflow-core';
import { TaskValidator } from './task-validator.js';
import { TaskQueueManager } from './task-queue.js';
import { TaskFileSync } from './task-file-sync.js';
import { TaskLoaderService } from './task-loader-service.js';
import { ContextUpdateService } from './context-update-service.js';
/**
 * State-specific action handler interface
 */
export interface StateActionHandler {
    handleStateSpecificActions(state: WorkflowState): Promise<void>;
}
/**
 * Rate limiting checker interface
 */
export interface RateLimitingChecker {
    checkRateLimiting(fileTaskData: any, taskData: any): Promise<void>;
}
/**
 * State history updater interface
 */
export interface StateHistoryUpdater {
    updateStateInHistory(taskData: any, currentState: WorkflowState, newState: WorkflowState): void;
}
/**
 * State persistence handler interface
 */
export interface StatePersistenceHandler {
    persistStateUpdate(activeQueueTask: any, taskData: any, taskId: string): Promise<void>;
}
/**
 * State prerequisites validator interface
 */
export interface StatePrerequisitesValidator {
    validateStatePrerequisites(state: WorkflowState): Promise<void>;
}
/**
 * Task State Orchestrator
 *
 * Orchestrates the entire state update flow by coordinating multiple services.
 */
export declare class TaskStateOrchestrator {
    private validator;
    private queueManager;
    private fileSync;
    private loaderService;
    private contextService;
    private taskFile;
    private stateActionHandler?;
    private rateLimitingChecker?;
    private stateHistoryUpdater?;
    private statePersistenceHandler?;
    private prerequisitesValidator?;
    constructor(validator: TaskValidator, queueManager: TaskQueueManager, fileSync: TaskFileSync, loaderService: TaskLoaderService, contextService: ContextUpdateService, taskFile: string, options?: {
        stateActionHandler?: StateActionHandler;
        rateLimitingChecker?: RateLimitingChecker;
        stateHistoryUpdater?: StateHistoryUpdater;
        statePersistenceHandler?: StatePersistenceHandler;
        prerequisitesValidator?: StatePrerequisitesValidator;
    });
    /**
     * Update task state
     *
     * Orchestrates the entire state update flow:
     * 1. Load task data
     * 2. Validate state transition
     * 3. Check rate limiting
     * 4. Update state in history
     * 5. Persist to queue/file
     * 6. Handle state-specific actions
     * 7. Update context
     *
     * @param state - New workflow state
     * @param getCurrentTask - Function to get current task (for context update)
     */
    updateState(state: WorkflowState, getCurrentTask: () => Promise<any>): Promise<void>;
    /**
     * Validate state update operation
     */
    private validateStateUpdate;
    /**
     * Fallback rate limiting check
     */
    private checkRateLimitingFallback;
    /**
     * Fallback state history update
     */
    private updateStateInHistoryFallback;
    /**
     * Fallback state persistence
     */
    private persistStateUpdateFallback;
}