import type { ModelCapabilityMetadata, ModelReasoningCapabilities, ModelSelectionSignals } from "@velum-labs/routekit-contracts";
import { Effect } from "effect";
import type { BackendRequest, BackendRequestOptions } from "../providers/backend.js";
import type { ProviderId, ProviderSource } from "../providers/source.js";
export type ModelCatalogEntry = ModelSelectionSignals & {
    readonly publicId: string;
    readonly nativeId: string;
    readonly provider: ProviderId;
    readonly capabilities: Readonly<Record<string, string>>;
    readonly metadata?: ModelCapabilityMetadata;
    readonly reasoning?: ModelReasoningCapabilities;
};
/** Immutable model inventory. It owns discovery results, not provider resources. */
export declare class ModelCatalog {
    #private;
    constructor(entries: Iterable<readonly [string, ModelCatalogEntry]>);
    ids(): readonly string[];
    get(id: string): ModelCatalogEntry | undefined;
    entries(): readonly ModelCatalogEntry[];
}
/** Pure model identity resolution over an immutable catalog. */
export declare class ModelResolver {
    readonly catalog: ModelCatalog;
    readonly defaultModel: string | undefined;
    constructor(catalog: ModelCatalog, defaultModel: string | undefined);
    resolve(requested: string | undefined): ModelCatalogEntry | undefined;
    resolveNative(requested: string, provider: string): ModelCatalogEntry | undefined;
}
/** Admission policy used while constructing a catalog. */
export declare class RoutePolicy {
    readonly allows: (canonicalModel: string) => boolean;
    constructor(allows: (canonicalModel: string) => boolean);
    admit(canonicalModel: string): boolean;
}
/** A fully resolved, immutable execution decision. */
export type RoutePlan = Readonly<{
    publicModel: string;
    nativeModel: string;
    provider: ProviderId;
    metadata?: ModelCapabilityMetadata;
    reasoning?: ModelReasoningCapabilities;
}>;
/** Converts model intent into a final route without performing I/O. */
export declare class RoutePlanner {
    readonly resolver: ModelResolver;
    constructor(resolver: ModelResolver);
    plan(requested: string | undefined, nativeProvider?: string): RoutePlan | undefined;
}
/** The sole port that performs provider request I/O for an already committed plan. */
export declare class BackendExecutor {
    #private;
    constructor(sources: readonly ProviderSource[]);
    supportsResponses(plan: RoutePlan): boolean;
    chat(plan: RoutePlan, body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): BackendRequest;
    responses(plan: RoutePlan, body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): BackendRequest;
    embeddings(plan: RoutePlan, body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): BackendRequest;
}
/** Explicit owner of provider resources and their live health probes. */
export declare class ProviderLifecycle {
    #private;
    constructor(sources: readonly ProviderSource[]);
    statuses(catalog: ModelCatalog, signal?: AbortSignal): Effect.Effect<({
        provider: "anthropic" | "google" | "openai" | "claude-code" | "codex" | "cliproxy" | "openrouter" | "bedrock";
        ok: boolean;
        models: string[];
        error: string;
    } | {
        provider: "anthropic" | "google" | "openai" | "claude-code" | "codex" | "cliproxy" | "openrouter" | "bedrock";
        ok: boolean;
        models: string[];
        error: string;
    } | {
        provider: "anthropic" | "google" | "openai" | "claude-code" | "codex" | "cliproxy" | "openrouter" | "bedrock";
        ok: boolean;
        models: string[];
        error?: undefined;
    })[], never, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
    close(): Effect.Effect<undefined, AggregateError, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
}