import { Context, Effect, type JsonSchema, Layer, Schema, Scope, Stream } from "effect";
import { AiError, LanguageModel, Model, Tool } from "effect/unstable/ai";
/** @experimental */
export type Metadata = Readonly<Record<string, unknown>>;
/** @experimental */
export interface GovernanceOptions {
    readonly maxConcurrentModelCalls?: number;
}
/** @experimental */
export interface ModelSelection {
    readonly provider: string;
    readonly model: string;
    readonly registrationKey?: string;
}
/** @experimental Immutable identity of one candidate within an ordered provider route. */
export interface CandidateIdentity extends ModelSelection {
    readonly candidate: number;
}
/** @experimental Disposition chosen for a failed provider attempt. */
export type FailureDisposition = "retry" | "fallback" | "terminal";
/** @experimental Instrumentation boundary supplied to a provider-owned candidate route. */
export interface CandidateRouteInstrumentation {
    readonly instrument: (model: LanguageModel.Service, identity: CandidateIdentity) => LanguageModel.Service;
    readonly settleFailure: (disposition: FailureDisposition) => Effect.Effect<void>;
    readonly fallbackScheduled: (input: {
        readonly from: CandidateIdentity;
        readonly to: CandidateIdentity;
        readonly error: unknown;
    }) => Effect.Effect<void>;
}
/** @experimental Provider-owned ordered candidate routing implementation. */
export type CandidateRoute = (instrumentation: CandidateRouteInstrumentation) => LanguageModel.Service;
/** @experimental Semantic classification of a model failure. */
export type FailureClassification = "context-overflow" | "other";
/** @experimental Provider-owned semantic model-failure classifier. */
export type FailureClassifier = (error: unknown) => FailureClassification;
/** @experimental Provider-owned decision that a failed invocation may advance an ordered candidate route. */
export type AvailabilityFailureClassifier = (error: unknown) => boolean;
/** @experimental Provider-owned compilation of a tool's exact request JSON Schema. */
export type ToolJsonSchemaCompiler = (tool: Tool.Any) => Effect.Effect<JsonSchema.JsonSchema, AiError.AiError>;
/** @experimental Classify a failure using semantics attached to the active registered model, falling back to provider-agnostic context-overflow evidence. */
export declare const classifyFailure: {
    (error: unknown): (model: LanguageModel.Service) => FailureClassification;
    (model: LanguageModel.Service, error: unknown): FailureClassification;
};
/** @experimental Read the compiler attached to the active registered or explicitly wrapped model. */
export declare const toolJsonSchemaCompiler: (model: LanguageModel.Service) => ToolJsonSchemaCompiler | undefined;
/** @experimental Attach a provider-exact tool JSON Schema compiler to a direct language model. */
export declare const withToolJsonSchemaCompiler: {
    (compiler: ToolJsonSchemaCompiler): (model: LanguageModel.Service) => LanguageModel.Service;
    (model: LanguageModel.Service, compiler: ToolJsonSchemaCompiler): LanguageModel.Service;
};
/** @experimental Attach a provider-owned candidate route at the raw model-attempt boundary. */
export declare const withCandidateRoute: {
    (route: CandidateRoute): (model: LanguageModel.Service) => LanguageModel.Service;
    (model: LanguageModel.Service, route: CandidateRoute): LanguageModel.Service;
};
/** @internal */
export declare const candidateRoute: (model: LanguageModel.Service) => CandidateRoute | undefined;
/** @internal */
export declare const registrationIdentity: (model: LanguageModel.Service) => ModelSelection | undefined;
declare const LanguageModelNotRegistered_base: Schema.Class<LanguageModelNotRegistered, Schema.TaggedStruct<"@batonfx/core/LanguageModelNotRegistered", {
    readonly provider: Schema.String;
    readonly model: Schema.String;
    readonly registration_key: Schema.optionalKey<Schema.String>;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class LanguageModelNotRegistered extends LanguageModelNotRegistered_base {
}
/** @experimental */
export interface Registration {
    readonly provider: string;
    readonly model: string;
    readonly registrationKey?: string;
    readonly layer: Layer.Layer<ModelEnvironment>;
    readonly metadata?: Metadata;
    readonly classifyFailure?: FailureClassifier;
    readonly toolJsonSchemaCompiler?: ToolJsonSchemaCompiler;
    readonly isAvailabilityFailure?: AvailabilityFailureClassifier;
}
/** @experimental */
export interface RegisterInput {
    readonly registration: Registration;
}
/** @experimental */
export interface Interface {
    readonly register: (input: RegisterInput) => Effect.Effect<void>;
    readonly registrations: Effect.Effect<ReadonlyArray<Registration>>;
    readonly operate: <A, E, R>(selection: ModelSelection, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | LanguageModelNotRegistered, Exclude<R, ModelEnvironment>>;
    readonly stream: <A, E, R>(selection: ModelSelection, stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E | LanguageModelNotRegistered, Exclude<R, ModelEnvironment>>;
}
declare const ModelRegistry_base: Context.ServiceClass<ModelRegistry, "@batonfx/core/model/model-registry/ModelRegistry", Interface>;
/** @experimental */
export declare class ModelRegistry extends ModelRegistry_base {
}
/** @experimental */
export type ModelEnvironment = LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName;
/** @experimental */
export declare const registration: <R>(input: {
    readonly provider: string;
    readonly model: string;
    readonly registrationKey?: string;
    readonly layer: Layer.Layer<LanguageModel.LanguageModel, never, R>;
    readonly metadata?: Metadata;
    readonly classifyFailure?: FailureClassifier;
    readonly toolJsonSchemaCompiler?: ToolJsonSchemaCompiler;
    readonly isAvailabilityFailure?: AvailabilityFailureClassifier;
}) => Effect.Effect<Registration, never, R>;
/** @experimental */
export declare const layer: {
    (): Layer.Layer<ModelRegistry>;
    <E = never, R = never>(options?: GovernanceOptions): (registrations?: ReadonlyArray<Effect.Effect<Registration, E, R>>) => Layer.Layer<ModelRegistry, E, Exclude<R, Scope.Scope>>;
    <E = never, R = never>(registrations?: ReadonlyArray<Effect.Effect<Registration, E, R>>, options?: GovernanceOptions): Layer.Layer<ModelRegistry, E, Exclude<R, Scope.Scope>>;
};
/** @experimental */
export declare const layerCombined: {
    <E = never, R = never>(options?: GovernanceOptions): (registries: ReadonlyArray<Layer.Layer<ModelRegistry, E, R>>) => Layer.Layer<ModelRegistry, E, R>;
    <E = never, R = never>(registries: ReadonlyArray<Layer.Layer<ModelRegistry, E, R>>, options?: GovernanceOptions): Layer.Layer<ModelRegistry, E, R>;
};
/** @experimental In-memory model registry. */
/** @experimental */
export declare const layerTest: (implementation: Interface) => Layer.Layer<ModelRegistry, never, never>;
/** @experimental */
export declare const register: (input: RegisterInput) => Effect.Effect<void, never, ModelRegistry>;
/** @experimental */
export declare const registrations: () => Effect.Effect<readonly Registration[], never, ModelRegistry>;
/** @experimental */
export declare const operate: {
    <A, E, R>(effect: Effect.Effect<A, E, R>): (selection: ModelSelection) => Effect.Effect<A, E | LanguageModelNotRegistered, ModelRegistry | Exclude<R, ModelEnvironment>>;
    <A, E, R>(selection: ModelSelection, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | LanguageModelNotRegistered, ModelRegistry | Exclude<R, ModelEnvironment>>;
};
/** @experimental */
export declare const stream: {
    <A, E, R>(operation: Stream.Stream<A, E, R>): (selection: ModelSelection) => Stream.Stream<A, E | LanguageModelNotRegistered, ModelRegistry | Exclude<R, ModelEnvironment>>;
    <A, E, R>(selection: ModelSelection, operation: Stream.Stream<A, E, R>): Stream.Stream<A, E | LanguageModelNotRegistered, ModelRegistry | Exclude<R, ModelEnvironment>>;
};
export {};