import type { ComposedWorkflowInterceptor } from '../interceptor.ts';
import type { HumanReviewOptions, HumanReviewResult } from '../review/index.ts';
import type { ActivityCallable, ActivityCallOptions, AwaitChildWorkflowOptions, ChildWorkflowHandle, ChildWorkflowTarget, DetachedChildWorkflowOptions, Duration, QueryDefinition, RunAllResult, SearchAttributeHandle, SearchAttributeValue, SignalDefinition, UpdateDefinition, WorkflowContext, WorkflowKeyedRaceResult, WorkflowLogger, WorkflowMapOptions, WorkflowOperation, WorkflowOperationTupleResult, WorkflowPipeStageDefinition, WorkflowReduceInput, WorkflowReduceOptions, WorkflowRunAllBranch, WorkflowStateNamespace } from '../types.ts';
import type { ContextOperationRequest } from './operation-request.ts';
import type { ContextOptions, ErasedSagaStep, OffloadReference, StreamReference, StreamSink } from './types.ts';
import * as contextUpdates from './updates.ts';
export type { ContextOperationRequest } from './operation-request.ts';
export type { ContextOptions, OffloadReference, SagaStep, StoredStreamChunk, StreamReference, StreamSink, } from './types.ts';
export declare function setContextWorkflowInterceptor(context: Context, workflowInterceptor: ComposedWorkflowInterceptor | null): void;
/**
 * Concrete workflow execution context injected as the first argument of every
 * registered workflow generator. Implements durable operations such as `run`,
 * `sleep`, `waitForSignal`, `review`, `offload`, `stream`, and `saga`.
 *
 * @example
 * ```ts
 * import { Context } from '@lostgradient/weft';
 *
 * const ctx = new Context({ workflowId: 'wf-demo', workflowType: 'demo', startedAt: Date.now(), abortController: new AbortController() });
 * void ctx;
 * ```
 */
export declare class Context implements WorkflowContext {
    #private;
    readonly workflowId: string;
    readonly workflowExecutionToken: string | undefined;
    readonly workflowType: string;
    readonly startedAt: number;
    readonly signal: AbortSignal;
    constructor(options: ContextOptions);
    get executionTimeRemaining(): number;
    get services(): unknown;
    get log(): WorkflowLogger;
    get stepIndex(): number;
    get nestingDepth(): number;
    get accumulatedResults(): Map<number, unknown>;
    get checkpointLocals(): Record<string, unknown>;
    get pendingAttributeChanges(): Record<string, SearchAttributeValue>;
    get exposedAccessors(): Map<string, () => unknown>;
    get updateHandlers(): Map<string, (payload: unknown) => unknown>;
    get updateValidators(): Map<string, (payload: unknown) => unknown>;
    get queryHandlers(): Map<string, (input: unknown) => unknown>;
    get explainEnabled(): boolean;
    get checkpointAccumulatedResults(): Array<[number, unknown]>;
    get checkpointPendingAttributeChanges(): Record<string, SearchAttributeValue> | undefined;
    createSpeculativeChild(): Context;
    commitSpeculativeChild(child: Context): void;
    get state(): WorkflowStateNamespace;
    run<TName extends string>(name: TName, input?: unknown, options?: ActivityCallOptions): Generator<ContextOperationRequest, unknown, unknown>;
    run<TResult>(fn: ActivityCallable<void, TResult>, options?: ActivityCallOptions): Generator<ContextOperationRequest, TResult, unknown>;
    run<TResult>(fn: (() => Promise<TResult> | TResult) & {
        execute?: never;
    }, options?: ActivityCallOptions): Generator<ContextOperationRequest, TResult, unknown>;
    run<TInput, TResult>(fn: ActivityCallable<TInput, TResult>, input: TInput, options?: ActivityCallOptions): Generator<ContextOperationRequest, TResult, unknown>;
    run<TInput, TResult>(fn: ((input: TInput) => Promise<TResult> | TResult) & {
        execute?: never;
    }, input: TInput, options?: ActivityCallOptions): Generator<ContextOperationRequest, TResult, unknown>;
    /**
     * Durably sleep for `duration` before continuing. Unlike a wall-clock
     * `setTimeout`, this is a checkpointed operation: the engine persists the timer
     * and resumes the workflow when it fires, so a sleep survives process restarts
     * and spans of days. On replay an already-elapsed sleep is a no-op — a
     * recovered workflow does not wait again. `duration` is milliseconds
     * (`number`) or a duration string (`'30s'`, `'1h'`, `'2d'` — see
     * {@link Duration}); drive it with `yield*` from a workflow body.
     */
    sleep(duration: Duration): Generator<ContextOperationRequest, void, unknown>;
    suspendUntil<T = unknown>(resumeToken: string): Generator<ContextOperationRequest, T, unknown>;
    waitForSignal<TInput>(definition: SignalDefinition<TInput>): Generator<ContextOperationRequest, TInput, unknown>;
    waitForSignal<T = unknown>(name: string): Generator<ContextOperationRequest, T, unknown>;
    waitForUpdate<TInput, TOutput>(definition: UpdateDefinition<TInput, TOutput>): Generator<ContextOperationRequest, {
        payload: TInput;
        respond: (result: TOutput) => void;
    }, unknown>;
    waitForUpdate<T = unknown>(name: string): Generator<ContextOperationRequest, {
        payload: T;
        respond: (result: unknown) => void;
    }, unknown>;
    waitUntil(predicate: () => boolean): Generator<ContextOperationRequest, void, unknown>;
    waitUntil(p: () => boolean, t: Duration): Generator<ContextOperationRequest, boolean, unknown>;
    getVersion(changeId: string, minSupported: number, maxSupported: number): Generator<ContextOperationRequest, number, unknown>;
    review(options: HumanReviewOptions): Generator<ContextOperationRequest, HumanReviewResult, unknown>;
    all<const TOperations extends readonly WorkflowOperation<unknown>[]>(operations: TOperations): Generator<ContextOperationRequest, WorkflowOperationTupleResult<TOperations>, unknown>;
    race<const TOperations extends readonly WorkflowOperation<unknown>[]>(operations: TOperations): Generator<ContextOperationRequest, WorkflowOperationTupleResult<TOperations>[number], unknown>;
    raceKeyed<const TOperations extends Readonly<Record<string, WorkflowOperation<unknown>>>>(operations: TOperations): Generator<ContextOperationRequest, WorkflowKeyedRaceResult<TOperations>, unknown>;
    memo<T>(key: string, fn: () => T | Promise<T>): Generator<ContextOperationRequest, T, unknown>;
    offload<T>(key: string, fn: () => Promise<T>): Generator<ContextOperationRequest, OffloadReference, unknown>;
    stream(key: string, fn: (sink: StreamSink) => AsyncGenerator<unknown, void, unknown>): Generator<ContextOperationRequest, StreamReference, unknown>;
    load<T>(reference: OffloadReference): Generator<ContextOperationRequest, T, unknown>;
    archive(key: string, data: unknown): Generator<ContextOperationRequest, void, unknown>;
    runAll<const TBranches extends Record<string, WorkflowRunAllBranch>>(branches: TBranches): Generator<ContextOperationRequest, RunAllResult<TBranches>, unknown>;
    saga<TFinalOutput = unknown>(steps: ErasedSagaStep[]): Generator<ContextOperationRequest, TFinalOutput, unknown>;
    startChild<TResult = unknown>(workflowType: string, input: unknown, options: DetachedChildWorkflowOptions): Generator<ContextOperationRequest, ChildWorkflowHandle<TResult>, unknown>;
    startChild<TResult = unknown>(workflowType: string, input: unknown, options?: AwaitChildWorkflowOptions): Generator<ContextOperationRequest, TResult, unknown>;
    pipe<TInput, TOutput>(stages: [WorkflowPipeStageDefinition<TInput, TOutput>], input: TInput): Generator<ContextOperationRequest, TOutput, unknown>;
    pipe<TInput, TIntermediate, TOutput>(stages: [
        WorkflowPipeStageDefinition<TInput, TIntermediate>,
        WorkflowPipeStageDefinition<TIntermediate, TOutput>
    ], input: TInput): Generator<ContextOperationRequest, TOutput, unknown>;
    pipe<TInput, TFirst, TSecond, TOutput>(stages: [
        WorkflowPipeStageDefinition<TInput, TFirst>,
        WorkflowPipeStageDefinition<TFirst, TSecond>,
        WorkflowPipeStageDefinition<TSecond, TOutput>
    ], input: TInput): Generator<ContextOperationRequest, TOutput, unknown>;
    pipe<TInput, TFirst, TSecond, TThird, TOutput>(stages: [
        WorkflowPipeStageDefinition<TInput, TFirst>,
        WorkflowPipeStageDefinition<TFirst, TSecond>,
        WorkflowPipeStageDefinition<TSecond, TThird>,
        WorkflowPipeStageDefinition<TThird, TOutput>
    ], input: TInput): Generator<ContextOperationRequest, TOutput, unknown>;
    map<TItem, TResult>(items: readonly TItem[], workflowType: ChildWorkflowTarget<TItem, TResult>, options?: WorkflowMapOptions): Generator<ContextOperationRequest, TResult[], unknown>;
    reduce<TItem, TAccumulator>(items: readonly TItem[], workflowType: ChildWorkflowTarget<WorkflowReduceInput<TAccumulator, TItem>, TAccumulator>, initialValue: TAccumulator, options?: WorkflowReduceOptions): Generator<ContextOperationRequest, TAccumulator, unknown>;
    explain(enabled?: boolean): void;
    speculate<TResult>(execute: (context: Context) => Generator<ContextOperationRequest, TResult, unknown> | AsyncGenerator<unknown, TResult, unknown>): Generator<ContextOperationRequest, TResult, unknown>;
    setAttribute<TValue extends SearchAttributeValue>(key: SearchAttributeHandle<TValue>, value: TValue): void;
    setAttribute(key: string, value: SearchAttributeValue): void;
    setAttributes(attributes: Record<string, SearchAttributeValue>): void;
    getAttribute<T extends SearchAttributeValue>(key: SearchAttributeHandle<T>): T | undefined;
    getAttribute<T extends SearchAttributeValue = SearchAttributeValue>(key: string): T | undefined;
    getAttributes(): Readonly<Record<string, SearchAttributeValue>>;
    onUpdate<TInput, TOutput>(definition: UpdateDefinition<TInput, TOutput>, handler: (payload: TInput) => TOutput | Promise<TOutput>, options?: contextUpdates.UpdateHandlerOptions): void;
    onUpdate(name: string, handler: (payload: unknown) => unknown, options?: contextUpdates.UpdateHandlerOptions): void;
    onQuery<TInput, TOutput>(definition: QueryDefinition<TInput, TOutput>, handler: (input: TInput) => TOutput | Promise<TOutput>): void;
    onQuery<TOutput>(definition: QueryDefinition<void, TOutput>, handler: () => TOutput | Promise<TOutput>): void;
    onQuery(name: string, handler: (input: unknown) => unknown): void;
    expose(accessors: Record<string, () => unknown>): void;
    onCancel(handler: () => Promise<void> | void): void;
    setFinalizerState(value: unknown): void;
    streamUrl(reference: StreamReference): string;
}