/**
 * Defines the provider-neutral service for text embeddings.
 *
 * An `EmbeddingModel` turns text into numeric vectors. It supports single-input
 * embedding and ordered batch embedding, and represents provider failures as
 * `AiError` values. This module also includes the embedding dimensions service,
 * request and response models, usage metadata, provider contracts, and a
 * constructor that adapts a provider batch implementation into the service.
 * Single `embed` calls can be batched together internally.
 *
 * @stability unstable
 * @since 4.0.0
 */
import * as Context from "../Context.ts";
import * as Effect from "../Effect.ts";
import * as Request from "../Request.ts";
import * as RequestResolver from "../RequestResolver.ts";
import * as Schema from "../Schema.ts";
import * as AiError from "./AiError.ts";
/**
 * Service key for embedding text into vectors.
 *
 * @see {@link make} for constructing an embedding model service from a provider
 * @see {@link Dimensions} for the current embedding vector size service
 *
 * @stability unstable
 * @category services
 * @since 4.0.0
 */
export declare const EmbeddingModel: Context.Service<EmbeddingModel, EmbeddingModel>;
/**
 * Brand type for `EmbeddingModel`.
 *
 * @stability unstable
 * @category type IDs
 * @since 4.0.0
 */
export type TypeId = "~effect/ai/EmbeddingModel";
/**
 * Brand for `EmbeddingModel` implementations.
 *
 * @stability unstable
 * @category type IDs
 * @since 4.0.0
 */
export declare const TypeId: TypeId;
declare const Dimensions_base: Context.ServiceClass<Dimensions, "effect/ai/EmbeddingModel/Dimensions", number>;
/**
 * Service tag that provides the current embedding dimensions.
 *
 * **When to use**
 *
 * Use to retrieve or provide the configured embedding vector size through
 * context.
 *
 * @see {@link EmbeddingModel} for the embedding service that uses these dimensions
 *
 * @stability unstable
 * @category services
 * @since 4.0.0
 */
export declare class Dimensions extends Dimensions_base {
}
declare const EmbeddingUsage_base: Schema.Class<EmbeddingUsage, Schema.Struct<{
    readonly inputTokens: Schema.optional<Schema.Finite>;
}>, {}>;
/**
 * Represents token usage metadata for embedding operations.
 *
 * **Details**
 *
 * Contains optional provider-reported `inputTokens`. The value may be
 * `undefined` when the provider does not report usage or when `embedMany([])`
 * bypasses the provider.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export declare class EmbeddingUsage extends EmbeddingUsage_base {
}
declare const EmbedResponse_base: Schema.Class<EmbedResponse, Schema.Struct<{
    readonly vector: Schema.$Array<Schema.Finite>;
}>, {}>;
/**
 * Response for a single embedding request.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export declare class EmbedResponse extends EmbedResponse_base {
}
declare const EmbedManyResponse_base: Schema.Class<EmbedManyResponse, Schema.Struct<{
    readonly embeddings: Schema.$Array<typeof EmbedResponse>;
    readonly usage: typeof EmbeddingUsage;
}>, {}>;
/**
 * Response for batch embedding requests containing per-input embeddings and usage
 * metadata.
 *
 * **Details**
 *
 * `embeddings` preserves batch order, and `usage` carries token metadata for
 * the operation.
 *
 * @see {@link EmbedResponse} for individual embedding responses
 * @see {@link EmbeddingUsage} for token usage metadata
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export declare class EmbedManyResponse extends EmbedManyResponse_base {
}
/**
 * Provider input options for embedding requests.
 *
 * @stability unstable
 * @category options
 * @since 4.0.0
 */
export interface ProviderOptions {
    readonly inputs: ReadonlyArray<string>;
}
/**
 * Provider response for batch embedding requests.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface ProviderResponse {
    readonly results: Array<Array<number>>;
    readonly usage: {
        readonly inputTokens: number | undefined;
    };
}
declare const EmbeddingRequest_base: new <A extends Record<string, any>, Success, Error = never, Services = never>(args: import("../Types.ts").Equals<Omit<A, "~effect/Request">, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | "~effect/Request" ? never : P]: A[P]; }) => Request.Request<Success, Error, Services> & Readonly<A> & {
    readonly _tag: "EmbeddingRequest";
};
/**
 * Represents a tagged request used by request resolvers for embedding operations.
 *
 * **When to use**
 *
 * Use when you need a typed request for one embedding input while building or
 * calling a low-level embedding request resolver.
 *
 * @see {@link EmbeddingModel} for the resolver-bearing service contract
 * @see {@link make} for constructing the request resolver from a provider implementation
 * @see {@link EmbedResponse} for the response produced by this request
 *
 * @stability unstable
 * @category constructors
 * @since 4.0.0
 */
export declare class EmbeddingRequest extends EmbeddingRequest_base<{
    readonly input: string;
}, EmbedResponse, AiError.AiError> {
}
/**
 * Single-input and batch embedding operations.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface EmbeddingModel {
    readonly [TypeId]: TypeId;
    readonly resolver: RequestResolver.RequestResolver<EmbeddingRequest>;
    readonly embed: (input: string) => Effect.Effect<EmbedResponse, AiError.AiError>;
    readonly embedMany: (input: ReadonlyArray<string>) => Effect.Effect<EmbedManyResponse, AiError.AiError>;
}
/**
 * Creates an EmbeddingModel service from a provider embedMany implementation.
 *
 * **When to use**
 *
 * Use to adapt a provider's batch embedding implementation into an
 * `EmbeddingModel` that offers single-input and batch embedding
 * operations.
 *
 * **Details**
 *
 * The returned service builds single-input `embed` calls through a request
 * resolver, so concurrent `embed` requests can be batched into one provider
 * `embedMany` call. Direct `embedMany` calls pass the input array to the
 * provider, while `embedMany([])` returns an empty response without calling the
 * provider.
 *
 * Concurrent `embed` calls share one `embedMany` call when `batchKey` returns
 * equal keys under `Equal.equals`. The batch runs with the first caller's
 * context, so return every value `embedMany` reads from that context. Without
 * `batchKey`, all callers share one batch.
 *
 * **Gotchas**
 *
 * Context that `batchKey` does not return is not isolated. Per-call
 * `FetchHttpClient.RequestInit`, or any service read by an injected HTTP
 * client, takes the first caller's value for the whole batch.
 *
 * Provider responses are interpreted positionally and must contain exactly one
 * result for each requested input. If the provider returns a different number
 * of results, `embed` and `embedMany` fail with `AiError.InvalidOutputError`.
 *
 * @see {@link EmbeddingModel} for the service shape returned by this constructor
 * @see {@link ProviderOptions} for the input passed to the provider implementation
 * @see {@link ProviderResponse} for the provider response contract consumed by this constructor
 *
 * @stability unstable
 * @category constructors
 * @since 4.0.0
 */
export declare const make: (params: {
    readonly embedMany: (options: ProviderOptions) => Effect.Effect<ProviderResponse, AiError.AiError>;
    readonly batchKey?: ((context: Context.Context<never>) => unknown) | undefined;
}) => Effect.Effect<EmbeddingModel>;
export {};
//# sourceMappingURL=EmbeddingModel.d.ts.map