/**
 * Fluent, predicate-driven querying over the flat {@link MODEL_CARDS} list.
 *
 * Rather than indexing the catalog into a nested map keyed by provider/api, we
 * accumulate an array of predicates and apply them lazily. Each chained method
 * narrows the candidate set; terminal methods (`all`, `find`) materialize it.
 * This keeps the catalog a single source of truth and makes filters composable
 * in any order.
 */
import type { ApiKind, ModelCard, ProviderId } from "../contract";
/**
 * Lazy, chainable query over a fixed pool of model cards. Filter methods return
 * a *new* selection (immutably accumulating predicates); terminal methods read
 * the result out.
 */
export declare class CardSelection {
    private readonly pool;
    private readonly tests;
    private constructor();
    /** Begin a query over the given pool (defaults to the full catalog). */
    static over(pool: readonly ModelCard[]): CardSelection;
    private withTest;
    /** Keep only cards from a specific vendor. */
    byProvider(provider: ProviderId): CardSelection;
    /** Keep only cards served over a specific wire dialect. */
    byApi(api: ApiKind): CardSelection;
    /** Keep cards whose reasoning capability matches `enabled`. */
    reasoning(enabled: boolean): CardSelection;
    /** Materialize every card that satisfies all accumulated predicates. */
    all(): ModelCard[];
    /**
     * Terminal lookup by exact `id`, also respecting any accumulated predicates.
     * Returns `undefined` when no surviving card matches.
     */
    find(id: string): ModelCard | undefined;
}
/** Entry point: open a fluent query over the full model catalog. */
export declare function models(): CardSelection;
/** Direct id lookup against the full catalog, bypassing the fluent builder. */
export declare function getCard(id: string): ModelCard | undefined;
