import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai";
import { ModelRegistry } from "@batonfx/core";
import { Config, Effect, Layer, Redacted, Schema } from "effect";
import type { ServiceInterface } from "./openai-account-auth.js";
import { HttpClient } from "effect/unstable/http";
/** @experimental */
export interface RegistrationOptions {
    readonly registrationKey?: string;
    readonly metadata?: ModelRegistry.Metadata;
}
/** @experimental */
export interface OpenAiInput extends RegistrationOptions {
    readonly model: (string & {}) | OpenAiLanguageModel.Model;
    readonly config?: Config;
}
/** @experimental */
export type Config = Omit<typeof OpenAiLanguageModel.Config.Service, "model">;
/** @experimental Decodes persisted provider options into OpenAI request configuration. */
export declare const decodeConfig: (options: unknown) => Config;
/** @experimental */
export declare const classifyFailure: ModelRegistry.FailureClassifier;
/** @experimental */
export declare const toolJsonSchemaCompiler: ModelRegistry.ToolJsonSchemaCompiler;
/** @experimental */
export interface LayerOptions extends OpenAiInput {
    readonly apiKey: Config.Config<Redacted.Redacted<string>>;
    readonly clientConfig?: Omit<NonNullable<Parameters<typeof OpenAiClient.layerConfig>[0]>, "apiKey">;
}
/** @experimental */
export declare const layer: (input: LayerOptions) => Layer.Layer<ModelRegistry.ModelRegistry, Config.ConfigError, HttpClient.HttpClient>;
/** @experimental Bare registration effect; the consumer provides the OpenAi client (see layerConfig). */
export declare const registration: (input: OpenAiInput) => Effect.Effect<ModelRegistry.Registration, never, OpenAiClient.OpenAiClient>;
/** @experimental */
export declare const normalizeResponsesSse: (client: HttpClient.HttpClient) => HttpClient.HttpClient;
/** @experimental */
export declare const layerConfig: (options?: Parameters<typeof OpenAiClient.layerConfig>[0]) => Layer.Layer<OpenAiClient.OpenAiClient, Config.ConfigError, HttpClient.HttpClient>;
/** @experimental */
export interface OpenAiAccountCredential {
    readonly accessToken: Redacted.Redacted<string>;
    readonly accountId: string;
    readonly generation: string;
}
declare const OpenAiAccountCredentialError_base: Schema.Class<OpenAiAccountCredentialError, Schema.TaggedStruct<"@batonfx/providers/OpenAiAccountCredentialError", {
    readonly operation: Schema.Literals<readonly ["acquire", "refreshRejected"]>;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class OpenAiAccountCredentialError extends OpenAiAccountCredentialError_base {
}
/** @experimental */
export interface OpenAiAccountCredentials {
    readonly acquire: Effect.Effect<OpenAiAccountCredential, OpenAiAccountCredentialError>;
    readonly refreshRejected: (generation: string) => Effect.Effect<OpenAiAccountCredential, OpenAiAccountCredentialError>;
}
/** @experimental */
export declare const credentialsFromAccountAuth: {
    (service: ServiceInterface, expectedFingerprint: string): OpenAiAccountCredentials;
    (expectedFingerprint: string): (service: ServiceInterface) => OpenAiAccountCredentials;
};
/** @experimental */
export interface OpenAiAccountInput extends RegistrationOptions {
    readonly model: (string & {}) | OpenAiLanguageModel.Model;
    readonly credentials: OpenAiAccountCredentials;
    readonly config?: Config;
}
/** @experimental Bare registration effect with the account-credential client bundled into the model layer. */
export declare const registrationAccount: (input: OpenAiAccountInput) => Effect.Effect<ModelRegistry.Registration, never, HttpClient.HttpClient>;
export declare const layerAccount: (input: OpenAiAccountInput) => Layer.Layer<ModelRegistry.ModelRegistry, never, HttpClient.HttpClient>;
export {};