import type { SerializedError } from '@pikku/core/errors';
import { PikkuWorkflowService } from '@pikku/core/workflow';
import type { WorkflowPlannedStep, WorkflowQueueOptions, WorkflowRun, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus } from '@pikku/core/workflow';
import { Redis, type RedisOptions } from 'ioredis';
export declare class RedisWorkflowService extends PikkuWorkflowService {
    private redis;
    private keyPrefix;
    private ownsConnection;
    private lockTTL;
    constructor(connectionOrConfig: Redis | RedisOptions | string | undefined, keyPrefix?: string, options?: WorkflowQueueOptions);
    init(): Promise<void>;
    private runKey;
    private stepKey;
    private stepHistoryKey;
    private lockKey;
    private stepLockKey;
    private saveStepHistory;
    private updateCurrentHistoryRecord;
    protected createRunImpl(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire, options?: {
        deterministic?: boolean;
        plannedSteps?: WorkflowPlannedStep[];
    }): Promise<string>;
    getRun(id: string): Promise<WorkflowRun | null>;
    protected updateRunStatusImpl(id: string, status: WorkflowStatus, output?: any, error?: SerializedError): Promise<void>;
    protected insertStepStateImpl(runId: string, stepName: string, rpcName: string | null, data: any, stepOptions?: {
        retries?: number;
        retryDelay?: string | number;
    }, fromStepName?: string): Promise<StepState>;
    getStepState(runId: string, stepName: string): Promise<StepState>;
    getRunHistory(runId: string): Promise<Array<StepState & {
        stepName: string;
    }>>;
    protected setStepRunningImpl(stepId: string): Promise<void>;
    protected setStepScheduledImpl(stepId: string): Promise<void>;
    protected setStepChildRunIdImpl(stepId: string, childRunId: string): Promise<void>;
    protected setStepResultImpl(stepId: string, result: any): Promise<void>;
    protected setStepErrorImpl(stepId: string, error: Error): Promise<void>;
    private withLock;
    withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>;
    withStepLock<T>(runId: string, stepName: string, fn: () => Promise<T>): Promise<T>;
    protected createRetryAttemptImpl(stepId: string, status: 'pending' | 'running'): Promise<StepState>;
    getCompletedGraphState(runId: string): Promise<{
        completedNodeIds: string[];
        failedNodeIds: string[];
        branchKeys: Record<string, string>;
    }>;
    getStepInstances(runId: string): Promise<Array<{
        stepName: string;
        status: StepStatus;
        fromStepName?: string;
    }>>;
    getNodeResults(runId: string, nodeIds: string[]): Promise<Record<string, any>>;
    protected setBranchTakenImpl(stepId: string, branchKey: string): Promise<void>;
    private runStateKey;
    protected updateRunStateImpl(runId: string, name: string, value: unknown): Promise<void>;
    getRunState(runId: string): Promise<Record<string, unknown>>;
    private versionKey;
    protected upsertWorkflowVersionImpl(name: string, graphHash: string, graph: any, source: string, status?: WorkflowVersionStatus): Promise<void>;
    protected updateWorkflowVersionStatusImpl(name: string, graphHash: string, status: WorkflowVersionStatus): Promise<void>;
    getWorkflowVersion(name: string, graphHash: string): Promise<{
        graph: any;
        source: string;
    } | null>;
    close(): Promise<void>;
}