/**
 * Model + framework registry — single source of truth per the model-release
 * playbook §8 item A; a release = one entry change here + rate-card row.
 */
export type ModelStatus = "ga" | "preview" | "announced" | "deprecated";
export interface ModelEntry {
    readonly id: string;
    readonly provider: "anthropic" | "openai" | "google" | "openrouter";
    readonly label: string;
    readonly status: ModelStatus;
    readonly isDefault?: true;
    readonly sunset?: string;
    /**
     * The picker's FRONT SLICE. `lineup` entries are what a model picker shows
     * without asking; every other invocable entry is reachable only behind the
     * picker's "See all models" door (founder ruling 2026-09-02, guuey#635:
     * "let's provide there 'see all models' and put fable5 there").
     *
     * This is a CURATION flag, not a claim about a model's provider lifecycle —
     * a non-`lineup` model is still Active, still served, still selectable. The
     * lifecycle lives in `status`/`sunset`, and Anthropic's own deprecations
     * page is the authority there (claude-fable-5 is Active with no deprecation
     * date, so it stays `ga` and merely moves behind the door).
     *
     * Anthropic's lineup is the current generation as of the 2026-09-02 wave
     * (Fable 5.1, Opus 5, Sonnet 5, Haiku 4.5 — the same four ggui pins, one
     * vocabulary across both fleets). OpenAI's and Google's stay deliberately
     * curated to their newest two, which is exactly the set those providers
     * showed before the door existed — the door widened what is REACHABLE, it
     * did not change what is shown up front.
     */
    readonly lineup?: true;
}
export interface FrameworkEntry {
    readonly framework: "claude-agent-sdk" | "openai-agents-sdk" | "google-adk" | "vanilla";
    readonly sdkPackage: string | null;
    readonly platformPinnedVersion: string | null;
    readonly facetSupportedRange: string | null;
    readonly defaultProvider: "anthropic" | "openai" | "google";
}
/**
 * Array order is picker order AFTER `modelsForProvider` floats the default to
 * the front.
 *
 * WHAT a picker shows up front is `lineup`, not a positional slice: the
 * platform's app-behavior picker renders `lineupForProvider` and puts
 * `legacyForProvider` behind a "See all models" door (guuey#637). Before that
 * door, the picker took google + openai's front slice with `.slice(0, 2)`, so
 * the second array entry per provider was product-visible by POSITION — that
 * is now carried by the flag instead, and array order only orders within each
 * half. Both halves are pinned by
 * `apps/platform/.../ModelSection/ModelSection.test.ts`.
 */
export declare const MODEL_REGISTRY: readonly ModelEntry[];
export declare const FRAMEWORK_REGISTRY: readonly FrameworkEntry[];
/**
 * The registry's ACCESSORS, bound to an explicit registry (guuey#634).
 *
 * Every predicate below closes over the models it judges. The live exports
 * further down are `bindRegistry(MODEL_REGISTRY)` — the one registry this
 * package ships — and that is what every product door imports. The seam
 * exists for one reason: the fail-closed rules for a not-yet-invocable
 * (`announced`) row must stay exercised in the weeks when NO live row is
 * announced (the July 2026 wave left that branch untested once; the Fable
 * 5.1 flip on 2026-09-08 would have again). A test binds the same code
 * over `[...MODEL_REGISTRY, <synthetic announced row>]` and proves the
 * exclusion — same predicates, never a re-implementation that could drift.
 * It is NOT a runtime extension point: a consumer that bound its own
 * registry would be the second source of truth the registry exists to
 * prevent.
 */
export interface RegistryAccessors {
    /** All invocable (ga|preview) models for a provider, default first. */
    modelsForProvider(p: ModelEntry["provider"]): readonly ModelEntry[];
    /** The picker's front slice — the `lineup` half of `modelsForProvider`. */
    lineupForProvider(p: ModelEntry["provider"]): readonly ModelEntry[];
    /** The other half — invocable models behind the "See all models" door. */
    legacyForProvider(p: ModelEntry["provider"]): readonly ModelEntry[];
    /** A provider's `announced` rows — display only, invocable by nothing. */
    announcedForProvider(p: ModelEntry["provider"]): readonly ModelEntry[];
    /** A framework's model axis — its default provider's invocable rows. */
    modelsForFramework(framework: FrameworkEntry["framework"]): readonly ModelEntry[];
    /** THE offered / off-registry predicate, fail-closed (guuey#647). */
    isOfferedModel(framework: FrameworkEntry["framework"], id: string): boolean;
    /** The default model id for a framework's default provider. */
    defaultModelFor(framework: FrameworkEntry["framework"]): string;
    /** Look up a model entry by id. */
    modelEntry(id: string): ModelEntry | undefined;
}
export declare function bindRegistry(models: readonly ModelEntry[], frameworks?: readonly FrameworkEntry[]): RegistryAccessors;
/**
 * Get all models for a provider, filtered to ga|preview only, with default first.
 */
export declare const modelsForProvider: RegistryAccessors["modelsForProvider"];
/**
 * The picker's FRONT SLICE for a provider — the `lineup` half of
 * `modelsForProvider`, default first (guuey#637).
 *
 * Together with {@link legacyForProvider} this PARTITIONS `modelsForProvider`:
 * every invocable model appears in exactly one half, so a picker built from
 * both can never silently drop a model the way a positional `.slice()` could.
 */
export declare const lineupForProvider: RegistryAccessors["lineupForProvider"];
/**
 * The other half — invocable models NOT in the front slice, in registry order.
 * These are what the picker's "See all models" door reveals: still Active,
 * still selectable, just superseded (Claude Fable 5, Sonnet 4.6, Opus 4.8 and
 * the older Gemini/GPT rows as of the 2026-09-02 wave).
 */
export declare const legacyForProvider: RegistryAccessors["legacyForProvider"];
/**
 * A provider's ANNOUNCED rows, in registry order — models the registry knows
 * about that are NOT invocable on our runtime yet.
 *
 * This is a DISPLAY accessor and nothing more (guuey#805). It is deliberately
 * OUTSIDE the `lineupForProvider` / `legacyForProvider` partition and outside
 * every offer predicate: `modelsForProvider`, `modelsForFramework`,
 * `isOfferedModel` and `defaultModelFor` keep failing closed on an announced
 * id exactly as they did before this existed (guuey#647), and the server's
 * create validator stays the backstop. Its only job is to let a console tell
 * the truth about a model it can see but cannot run — rendered as a DISABLED
 * entry with an honest face, so a builder can never create an app whose first
 * turn dies on a model the runtime refuses.
 *
 * Only `status === 'announced'` comes back: a `deprecated` row is not
 * announced and stays hidden here just as it is hidden from the pickers.
 * Empty for every provider since the 2026-09-08 Fable 5.1 flip — a real
 * state the consoles render as "nothing announced", not a vacuous one: the
 * registry tests keep the accessor honest over a synthetic announced row.
 */
export declare const announcedForProvider: RegistryAccessors["announcedForProvider"];
/**
 * The model AXIS a framework's picker offers — its default provider's
 * invocable (ga|preview) rows, default first: `modelsForProvider` keyed by
 * framework. Every door that judges an `intendedModel` (the console's rack
 * and deploy snapshot, the backend's create validator) derives THIS list, so
 * no two of them can disagree about what "offered" means (guuey#647).
 */
export declare const modelsForFramework: RegistryAccessors["modelsForFramework"];
/**
 * Is `id` on `framework`'s model axis? THE offered / off-registry predicate
 * (guuey#647), fail-closed: an `announced` row (known, not invocable), a
 * `deprecated` row, another provider's model and an id the registry has
 * never heard of all answer false. One rule for every door — a client that
 * copied it would be the second source of truth this exists to prevent.
 */
export declare const isOfferedModel: RegistryAccessors["isOfferedModel"];
/**
 * Get the default model id for a framework's default provider.
 */
export declare const defaultModelFor: RegistryAccessors["defaultModelFor"];
/**
 * Look up a model entry by id.
 */
export declare const modelEntry: RegistryAccessors["modelEntry"];
//# sourceMappingURL=registry.d.ts.map