import { MiddlewareType, Run, GetRunContext } from './context.js';
import { FrameworkError } from './errors.js';
import { Serializable } from './internals/serializable.js';
import { E as Emitter } from './emitter-kHxkUxco.js';
import { BaseMemory } from './memory/base.js';
import { OmitEmpty } from './internals/types.js';
import { AnyTool } from './tools/base.js';

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

interface AgentMeta {
    name: string;
    description: string;
    extraDescription?: string;
    tools: AnyTool[];
}
type AgentCallbackValue = {
    data?: never;
    error: Error;
} | {
    data: unknown;
    error?: never;
} | object;
type InternalAgentCallbackValue<T extends AgentCallbackValue, E extends NonNullable<unknown>> = OmitEmpty<T> & E;
type PublicAgentCallbackValue<T extends AgentCallbackValue = AgentCallbackValue> = OmitEmpty<T>;
type AgentCallback<T extends PublicAgentCallbackValue> = (value: T) => void;
type GetAgentInput<T> = T extends BaseAgent<infer X, any, any> ? X : never;
type GetAgentOutput<T> = T extends BaseAgent<any, infer X, any> ? X : never;
type AnyAgent = BaseAgent<any, any, any>;

declare class AgentError extends FrameworkError {
}
interface BaseAgentRunOptions {
    signal?: AbortSignal;
}
declare abstract class BaseAgent<TInput, TOutput, TOptions extends BaseAgentRunOptions = BaseAgentRunOptions> extends Serializable {
    protected isRunning: boolean;
    abstract readonly emitter: Emitter<unknown>;
    readonly middlewares: MiddlewareType<typeof this>[];
    run(...[input, options]: Partial<TOptions> extends TOptions ? [input: TInput, options?: TOptions] : [input: TInput, options: TOptions]): Run<TOutput, this, readonly [TInput, TOptions | undefined]>;
    protected abstract _run(input: TInput, options: TOptions, run: GetRunContext<typeof this>): Promise<TOutput>;
    destroy(): void;
    abstract set memory(memory: BaseMemory);
    abstract get memory(): BaseMemory;
    get meta(): AgentMeta;
    createSnapshot(): {
        isRunning: boolean;
        emitter: Emitter<unknown>;
        middlewares: MiddlewareType<any>[];
    };
    loadSnapshot(snapshot: ReturnType<typeof this.createSnapshot>): void;
}

export { AgentError as A, BaseAgent as B, type GetAgentInput as G, type InternalAgentCallbackValue as I, type PublicAgentCallbackValue as P, type BaseAgentRunOptions as a, type AnyAgent as b, type AgentMeta as c, type AgentCallback as d, type AgentCallbackValue as e, type GetAgentOutput as f };