import { Duration, Effect, Layer } from "effect";
import { AiError, LanguageModel, ModelRegistry, Prompt, Response, Tool } from "@batonfx/core";
/** @experimental */
export interface TextPart {
    readonly _tag: "Text";
    readonly text: string;
}
/** @experimental */
export interface ReasoningPart {
    readonly _tag: "Reasoning";
    readonly text: string;
}
/** @experimental */
export interface ToolCallPart {
    readonly _tag: "ToolCall";
    readonly name: string;
    readonly params: unknown;
    readonly id?: string;
    readonly providerExecuted: boolean;
}
/** @experimental */
export type Part = TextPart | ReasoningPart | ToolCallPart;
/** @experimental */
export interface StepOptions {
    readonly finishReason?: Response.FinishReason;
    readonly usage?: Response.Usage;
    readonly delay?: Duration.Input;
    readonly streamPartDelay?: Duration.Input;
}
/** @experimental */
export interface TurnStep extends StepOptions {
    readonly _tag: "Turn";
    readonly parts: ReadonlyArray<Part>;
}
/**
 * @experimental Where a truncated step stops emitting. The stream always ends
 * without a `finish` part, reproducing a provider body that reached EOF without
 * its terminal event.
 */
export type TruncationPoint = "reasoning-delta" | "text-delta" | "tool-params-delta" | "response-metadata";
/** @experimental A provider stream that ends mid-content and never emits `finish`. */
export interface TruncatedStep {
    readonly _tag: "Truncated";
    readonly parts: ReadonlyArray<Part>;
    readonly stopAfter: TruncationPoint;
    readonly delay?: Duration.Input;
    readonly streamPartDelay?: Duration.Input;
}
/** @experimental */
export interface ObjectStep extends StepOptions {
    readonly _tag: "Object";
    readonly value: unknown;
}
/** @experimental */
export interface FailureStep {
    readonly _tag: "Failure";
    readonly error: AiError.AiError;
    readonly delay?: Duration.Input;
}
/** @experimental */
export type Step = Part | TurnStep | ObjectStep | FailureStep | TruncatedStep;
/** @experimental */
export interface ToolCallOptions {
    readonly id?: string;
    readonly providerExecuted?: boolean;
}
/** @experimental */
export interface MakeOptions {
    readonly provider?: string;
    readonly model?: string;
    readonly registrationKey?: string;
    readonly metadata?: ModelRegistry.Metadata;
}
/** @experimental */
export type Operation = "streamText" | "generateText" | "generateObject";
/** @experimental */
export interface Request {
    readonly index: number;
    readonly operation: Operation;
    readonly prompt: Prompt.Prompt;
    readonly tools: ReadonlyArray<Tool.Any>;
    readonly toolChoice: LanguageModel.ProviderOptions["toolChoice"];
    readonly responseFormat: LanguageModel.ProviderOptions["responseFormat"];
    readonly previousResponseId: string | undefined;
    readonly incrementalPrompt: Prompt.Prompt | undefined;
}
/** @experimental */
export interface Fixture {
    readonly layer: Layer.Layer<LanguageModel.LanguageModel>;
    readonly selection: ModelRegistry.ModelSelection;
    readonly registration: ModelRegistry.Registration;
    readonly registryLayer: Layer.Layer<ModelRegistry.ModelRegistry>;
    readonly requests: Effect.Effect<ReadonlyArray<Request>>;
    readonly prompts: Effect.Effect<ReadonlyArray<Prompt.Prompt>>;
    readonly remaining: Effect.Effect<number>;
    readonly awaitRequests: (count: number) => Effect.Effect<ReadonlyArray<Request>>;
}
/** @experimental */
export declare const text: (value: string) => TextPart;
/** @experimental */
export declare const reasoning: (value: string) => ReasoningPart;
/** @experimental */
export declare const toolCall: {
    (params: unknown, options?: ToolCallOptions): (name: string) => ToolCallPart;
    (name: string, params: unknown, options?: ToolCallOptions): ToolCallPart;
};
/** @experimental */
export declare const turn: {
    (options?: StepOptions): (parts: ReadonlyArray<Part>) => TurnStep;
    (parts: ReadonlyArray<Part>, options?: StepOptions): TurnStep;
};
/**
 * @experimental A turn whose provider stream ends without a `finish` part.
 * `stopAfter: "tool-params-delta"` emits `tool-params-start` and unclosed
 * parameter JSON but never the closing `tool-call`.
 */
export declare const truncated: {
    (options: {
        readonly stopAfter: TruncationPoint;
        readonly delay?: Duration.Input;
        readonly streamPartDelay?: Duration.Input;
    }): (parts: ReadonlyArray<Part>) => TruncatedStep;
    (parts: ReadonlyArray<Part>, options: {
        readonly stopAfter: TruncationPoint;
        readonly delay?: Duration.Input;
        readonly streamPartDelay?: Duration.Input;
    }): TruncatedStep;
};
/** @experimental */
export declare const object: {
    (options?: StepOptions): (value: unknown) => ObjectStep;
    (value: unknown, options?: StepOptions): ObjectStep;
};
/** @experimental */
export declare const failure: {
    (options?: {
        readonly delay?: Duration.Input;
    }): (error: AiError.AiError) => FailureStep;
    (error: AiError.AiError, options?: {
        readonly delay?: Duration.Input;
    }): FailureStep;
};
/** @experimental */
export declare const make: {
    (options?: MakeOptions): (script: ReadonlyArray<Step>) => Effect.Effect<Fixture>;
    (script: ReadonlyArray<Step>, options?: MakeOptions): Effect.Effect<Fixture>;
};
/** @experimental */
export declare const layer: {
    (options?: MakeOptions): (script: ReadonlyArray<Step>) => Layer.Layer<LanguageModel.LanguageModel>;
    (script: ReadonlyArray<Step>, options?: MakeOptions): Layer.Layer<LanguageModel.LanguageModel>;
};
/** @experimental */
export declare const layerRegistry: {
    (governance?: ModelRegistry.GovernanceOptions): (fixtures: ReadonlyArray<Fixture>) => Layer.Layer<ModelRegistry.ModelRegistry>;
    (fixtures: ReadonlyArray<Fixture>, governance?: ModelRegistry.GovernanceOptions): Layer.Layer<ModelRegistry.ModelRegistry>;
};