import { Duration, Schema, Stream } from "effect";
import { Response } from "effect/unstable/ai";
/**
 * @experimental What already escaped downstream when a model part stream ended
 * without its terminal `finish` part. `Nothing` means no part a consumer would
 * render or replay reached it, so the attempt can be retried without
 * duplicating transcript content.
 */
export declare const EmittedOutput: Schema.Union<readonly [Schema.Struct<{
    readonly _tag: Schema.tag<"Nothing">;
}>, Schema.Struct<{
    readonly _tag: Schema.tag<"DisplayOnly">;
    readonly characters: Schema.Finite;
}>, Schema.Struct<{
    readonly _tag: Schema.tag<"OpenToolCall">;
    readonly toolCallId: Schema.String;
    readonly toolName: Schema.String;
    readonly characters: Schema.Finite;
}>]>;
/** @experimental */
export type EmittedOutput = typeof EmittedOutput.Type;
declare const ModelStreamTruncated_base: Schema.Class<ModelStreamTruncated, Schema.TaggedStruct<"@batonfx/core/ModelStreamTruncated", {
    turn: Schema.Finite;
    provider: Schema.optionalKey<Schema.String>;
    model: Schema.optionalKey<Schema.String>;
    requestId: Schema.optionalKey<Schema.String>;
    lastPart: Schema.optionalKey<Schema.String>;
    emitted: Schema.Union<readonly [Schema.Struct<{
        readonly _tag: Schema.tag<"Nothing">;
    }>, Schema.Struct<{
        readonly _tag: Schema.tag<"DisplayOnly">;
        readonly characters: Schema.Finite;
    }>, Schema.Struct<{
        readonly _tag: Schema.tag<"OpenToolCall">;
        readonly toolCallId: Schema.String;
        readonly toolName: Schema.String;
        readonly characters: Schema.Finite;
    }>]>;
}>, import("effect/Cause").YieldableError>;
/**
 * @experimental A provider part stream reached a clean end without its terminal
 * `finish` part, so the attempt produced no finish reason and no usage.
 */
export declare class ModelStreamTruncated extends ModelStreamTruncated_base {
}
declare const ModelStreamTimeout_base: Schema.Class<ModelStreamTimeout, Schema.TaggedStruct<"@batonfx/core/ModelStreamTimeout", {
    readonly turn: Schema.Finite;
    readonly provider: Schema.optionalKey<Schema.String>;
    readonly model: Schema.optionalKey<Schema.String>;
    readonly requestId: Schema.optionalKey<Schema.String>;
    readonly lastPart: Schema.optionalKey<Schema.String>;
    readonly emitted: Schema.Union<readonly [Schema.Struct<{
        readonly _tag: Schema.tag<"Nothing">;
    }>, Schema.Struct<{
        readonly _tag: Schema.tag<"DisplayOnly">;
        readonly characters: Schema.Finite;
    }>, Schema.Struct<{
        readonly _tag: Schema.tag<"OpenToolCall">;
        readonly toolCallId: Schema.String;
        readonly toolName: Schema.String;
        readonly characters: Schema.Finite;
    }>]>;
    readonly idleMillis: Schema.Finite;
}>, import("effect/Cause").YieldableError>;
/** @experimental A provider part stream exceeded its configured idle deadline. */
export declare class ModelStreamTimeout extends ModelStreamTimeout_base {
}
/** @experimental A model part stream did not reach a provider-reported terminal event. */
export type TerminationFailure = ModelStreamTruncated | ModelStreamTimeout;
/** @experimental Whether a failure means the stream did not reach its terminal event. */
export declare const isTerminationFailure: (error: unknown) => error is TerminationFailure;
/** @experimental Whether a model stream exceeded its configured idle deadline. */
export declare const isModelStreamTimeout: (error: unknown) => error is ModelStreamTimeout;
/** @experimental Provenance stamped onto a termination failure. */
export interface Origin {
    readonly turn: number;
    readonly provider: string | undefined;
    readonly model: string | undefined;
}
/**
 * @experimental Fail a provider part stream that ended without its terminal
 * `finish` part. A clean end with no `finish` fails with `ModelStreamTruncated`.
 * When `idleTimeout` is present, a pull that exceeds it fails with
 * `ModelStreamTimeout`; absence applies no idle deadline.
 */
export declare const requireTerminal: {
    <A>(options: Origin & {
        readonly toPart: (value: A) => Response.AnyPart;
        readonly idleTimeout?: Duration.Input;
    }): <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E | TerminationFailure, R>;
    <A, E, R>(self: Stream.Stream<A, E, R>, options: Origin & {
        readonly toPart: (value: A) => Response.AnyPart;
        readonly idleTimeout?: Duration.Input;
    }): Stream.Stream<A, E | TerminationFailure, R>;
};
export {};