/**
 * Platinum Inference as a regular BYOK provider. It is not on models.dev, so
 * it is appended to every catalog (the bundled snapshot, its id/env projection,
 * and the API's live models.dev refresh). Its models are not listed here: the
 * API reads them from Platinum's `/models` with the project's own key
 * (apps/api llm-gateway/models/platinum-models.ts).
 */
export declare const PLATINUM_PROVIDER: CatalogProvider;
export { DEFAULT_ENABLEMENT_WINDOW_MONTHS, defaultEnabledModelIds, type EnablementCandidate, autoSeedDefaultModel, autoSeedableModels, bedrockInferenceProfileRank, } from './enablement.js';
export interface ProviderAuthMethod {
    /** Optional label, surfaced only if a provider ever exposes >1 method in the UI (none do today — the connect form always uses methods[0]). */
    label?: string;
    /** Every one of these project-secret env vars must be set for this method to count as satisfied. */
    envVars: string[];
}
export interface ProviderAuthRequirement {
    /**
     * One or more independent ways to authenticate. A provider is CONNECTED if
     * ANY method's envVars are all present — see `isProviderAuthSatisfied`.
     */
    methods: ProviderAuthMethod[];
}
interface CatalogProviderLike {
    id: string;
    env?: string[];
}
/** `opencode-go` → `OPENCODE_GO_API_KEY`: the provider's own key name. */
export declare function providerOwnKeyName(providerId: string): string;
/**
 * The auth requirement Kortix actually enforces for a catalog provider.
 * Falls back to a single method requiring every var in `provider.env`
 * (unchanged behavior) unless an override above corrects it. A key name
 * several providers claim belongs to one of them (see SHARED_KEY_OWNER).
 */
export declare function providerAuthRequirement(provider: CatalogProviderLike): ProviderAuthRequirement;
/**
 * The env vars the connect form should collect for a provider — always the
 * first (primary) auth method. Every provider has exactly one usable method
 * today; this is the field list `ApiKeyConnectForm` renders and writes.
 */
export declare function primaryAuthEnvVars(provider: CatalogProviderLike): string[];
/**
 * True when at least one of the requirement's auth methods has every one of
 * its env vars present, per `hasEnvVar`. ANY-OF-methods, ALL-OF-vars-within-
 * a-method — the one predicate every "is this provider connected" check
 * (web connect modal, model-selector gating, native-mode provider merge, CLI
 * `providers ls`) should use instead of hand-rolling `envVars.every(...)`
 * over the raw catalog list.
 */
export declare function isProviderAuthSatisfied(requirement: ProviderAuthRequirement, hasEnvVar: (envVar: string) => boolean): boolean;
export interface CatalogReasoningOption {
    type: string;
    values?: string[];
    min?: number;
    max?: number;
}
export interface CatalogCostTier {
    input?: number;
    output?: number;
    cache_read?: number;
    cache_write?: number;
    tier?: {
        type: string;
        size: number;
    };
}
export interface CatalogCost {
    input?: number;
    output?: number;
    cache_read?: number;
    cache_write?: number;
    tiers?: CatalogCostTier[];
    context_over_200k?: CatalogCostTier;
}
export interface CatalogModalities {
    input?: string[];
    output?: string[];
}
export interface CatalogModel {
    id: string;
    name: string;
    released?: string | null;
    status?: string;
    description?: string;
    attachment?: boolean;
    reasoning?: boolean;
    reasoning_options?: CatalogReasoningOption[];
    tool_call?: boolean;
    temperature?: boolean;
    structured_output?: boolean;
    interleaved?: boolean | {
        field?: string;
    };
    open_weights?: boolean;
    knowledge?: string;
    last_updated?: string;
    family?: string;
    modalities?: CatalogModalities;
    limit?: {
        context?: number;
        input?: number;
        output?: number;
    };
    cost?: CatalogCost;
    provider?: {
        npm?: string;
        api?: string;
    };
}
/** Generic per-model generation defaults a project can configure. Extensible
 *  without a schema/migration change — see packages/db's jsonb column. */
export interface GenerationConfig {
    reasoningEffort?: string;
    temperature?: number;
    topP?: number;
    maxOutputTokens?: number;
}
export interface GenerationControlCapabilities {
    /**
     * Present iff the model publishes a REAL reasoning_options knob — from
     * EITHER an `effort` entry (its exact `values`) OR a `budget_tokens` entry
     * (a synthesized standard low/medium/high tier set — `budget_tokens` has no
     * discrete values of its own, but it IS a real published knob, e.g. every
     * mainline Claude model, which the transport maps via
     * `resolveAnthropicThinkingBudget`/`REASONING_EFFORT_BUDGET_TOKENS`
     * — so exposing an effort-style control for it is not fabrication the way
     * inventing one for a bare `reasoning:true` model with NO reasoning_options
     * at all would be). A `toggle` entry gets no control here (on/off is not an
     * effort enum) but does not crash — see the `toggle` branch below. Absent
     * entirely when the model publishes no real reasoning_options at all (we
     * never fabricate one out of thin air).
     */
    reasoningEffort?: {
        values: string[];
    };
    /** True iff the model accepts a client-supplied temperature (models.dev
     *  `temperature:false` means FIXED — e.g. gpt-5.6-sol — hide the control). */
    temperature: boolean;
    /** top_p has no distinct models.dev flag — gated on the same standard-
     *  sampling capability as temperature (documented heuristic: models that
     *  reject a custom temperature reject a custom top_p too). */
    topP: boolean;
    /** Present iff the model declares a positive max output-token window —
     *  the ceiling a "max output tokens" control must clamp to. */
    maxOutputTokens?: {
        ceiling: number;
    };
}
/** Pure capability derivation — NEVER a per-model id lookup table. */
export declare function generationControlCapabilities(model: CatalogModel | undefined | null): GenerationControlCapabilities;
/**
 * Drop/clamp every field of a (possibly user- or client-supplied)
 * `GenerationConfig` against what `model` actually supports — the single
 * gate BOTH the routing-policy write path (persistence) and the gateway
 * resolution-layer injection path (see apps/api's routing/resolve-route.ts)
 * must run a value through before it's trusted. A field the model doesn't
 * support is silently dropped (never a validation error) so a model swap
 * doesn't require the caller to also scrub unrelated config.
 */
export declare function clampGenerationConfig(config: GenerationConfig | null | undefined, model: CatalogModel | undefined | null): GenerationConfig;
export interface CatalogProvider {
    id: string;
    name: string;
    env?: string[];
    doc?: string;
    api?: string | null;
    npm?: string | null;
    models: CatalogModel[];
}
export interface Catalog {
    source: string;
    fetched_at: string;
    provider_count: number;
    model_count: number;
    providers: CatalogProvider[];
}
/**
 * `{ id, env }` for every provider in `CATALOG`, in the same order — the only
 * catalog fields `providerAuthRequirement` reads. ~8 KB instead of the ~7.6 MB
 * snapshot, for browser code that needs provider credentials but no models.
 * Regenerated together with the snapshot; catalog-isolation.test.ts checks
 * that the two agree.
 */
export declare const CATALOG_PROVIDER_ENV: readonly {
    id: string;
    env: string[];
}[];
export declare const MODEL_SELECTOR_PROVIDER_IDS: readonly ["kortix", "opencode", "anthropic", "openai", "github-copilot", "google", "openrouter", "vercel"];
export declare const PROVIDER_LABELS: Record<string, string>;
//# sourceMappingURL=lite.d.ts.map