import { E as Emitter, C as Callback } from './emitter-D4OcelZ9.cjs';
import { Serializable } from './internals/serializable.cjs';
import { LazyPromise } from './internals/helpers/promise.cjs';
import { FrameworkError } from './errors.cjs';
import './internals/types.cjs';
import './internals/helpers/guards.cjs';

/**
 * Copyright 2025 © BeeAI a Series of LF Projects, LLC
 * SPDX-License-Identifier: Apache-2.0
 */

interface RunInstance<T = any> {
    emitter: Emitter<T>;
}
interface RunContextCallbacks {
    start: Callback<{
        input: any;
        output: any;
    }>;
    success: Callback<unknown>;
    error: Callback<Error>;
    finish: Callback<{
        input: any;
        output?: any;
        error?: FrameworkError;
    }>;
}
declare abstract class Middleware<T extends RunInstance = any> {
    abstract bind(ctx: RunContext<T>): void;
}
type GetRunContext<T, P = any> = T extends RunInstance ? RunContext<T, P> : never;
type GetRunInstance<T> = T extends RunInstance<infer P> ? P : never;
type MiddlewareFn<T> = (context: GetRunContext<T>) => void;
type MiddlewareType<T extends RunInstance> = Middleware<T> | MiddlewareFn<T>;
declare class Run<R, I extends RunInstance, P = any> extends LazyPromise<R> {
    protected readonly runContext: GetRunContext<I, P>;
    protected readonly tasks: (() => Promise<void>)[];
    constructor(handler: () => Promise<R>, runContext: GetRunContext<I, P>);
    readonly [Symbol.toStringTag] = "Promise";
    observe(fn: (emitter: Emitter<GetRunInstance<I>>) => void): this;
    context(value: object): this;
    middleware(...fns: MiddlewareType<I>[]): this;
    protected before(): Promise<void>;
    [Symbol.asyncIterator](): R extends AsyncIterable<infer X> ? AsyncIterator<X> : never;
}
interface RunContextInput<P> {
    params: P;
    signal?: AbortSignal;
}
declare class RunContext<T extends RunInstance, P = any> extends Serializable {
    #private;
    readonly instance: T;
    protected readonly input: RunContextInput<P>;
    protected readonly controller: AbortController;
    readonly runId: string;
    readonly groupId: string;
    readonly parentId?: string;
    readonly emitter: Emitter<GetRunInstance<T>>;
    readonly context: object;
    runParams: P;
    readonly createdAt: Date;
    get signal(): AbortSignal;
    abort(reason?: Error): void;
    constructor(instance: T, input: RunContextInput<P>, parent?: RunContext<any>);
    destroy(): void;
    static enter<C2 extends RunInstance, R2, P2>(instance: C2, input: RunContextInput<P2>, fn: (context: GetRunContext<C2, P2>) => Promise<R2>): Run<R2, C2, P2>;
    createSnapshot(): {
        controller: AbortController;
        runId: string;
        groupId: string;
        parentId: string | undefined;
        emitter: Emitter<GetRunInstance<T>>;
        context: object;
        runParams: P;
        createdAt: Date;
    };
    loadSnapshot(snapshot: ReturnType<typeof this.createSnapshot>): void;
}

export { type GetRunContext, type GetRunInstance, Middleware, type MiddlewareFn, type MiddlewareType, Run, RunContext, type RunContextCallbacks, type RunContextInput, type RunInstance };