import { Cause, Effect, Option, Schema } from "effect";
import { Response, ResponseIdTracker } from "effect/unstable/ai";
import type { Classification, Interface as Resilience } from "./model-resilience.js";
import type { EventPayload, ModelFailureCategory, ModelFirstOutputKind } from "./model-telemetry.js";
export declare const disabledResponseIdTracker: ResponseIdTracker.Service;
export declare const ModelProviderUsage: Schema.Struct<{
    readonly inputTokens: Schema.optionalKey<Schema.Int>;
    readonly outputTokens: Schema.optionalKey<Schema.Int>;
    readonly totalTokens: Schema.optionalKey<Schema.Int>;
}>;
export type ModelProviderUsage = typeof ModelProviderUsage.Type;
declare const responseUsageToProviderUsage: (usage: Response.Usage) => ModelProviderUsage | undefined;
declare const providerUsageFromError: (error: unknown) => ModelProviderUsage | undefined;
declare const addProviderUsage: (left: ModelProviderUsage | undefined, right: ModelProviderUsage | undefined) => ModelProviderUsage | undefined;
export declare const providerUsage: {
    add: typeof addProviderUsage;
    fromError: typeof providerUsageFromError;
    fromResponse: typeof responseUsageToProviderUsage;
};
export declare const memoized: <Result>(compute: (error: unknown) => Result) => ((error: unknown) => Result);
export declare const singleFailure: (cause: Cause.Cause<unknown>) => Option.Option<unknown>;
export declare const firstOutputKind: (part: Response.AnyPart) => ModelFirstOutputKind | undefined;
interface RetryContext {
    readonly resilience: Resilience;
    readonly classify: (error: unknown) => Classification;
    readonly categorize: (error: unknown) => ModelFailureCategory;
    readonly attempt: () => number;
    readonly turn: number;
    readonly modelCallId: string;
    readonly emit: (event: EventPayload) => Effect.Effect<void>;
    readonly settleFailure: Effect.Effect<void>;
}
export declare const tapRetryTelemetry: (context: RetryContext) => Resilience;
export {};