@pokewallet/sdk 0.0.0-stage → 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,2859 @@
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+interface ClientOptions {
+    /**
+     * API key (`pk_…`). Falls back to the `POKEWALLET_API_KEY` environment variable. Optional at
+     * construction: only `health()` and `listGames()` work without one, every other call throws
+     * `ValidationError` before touching the network.
+     */
+    apiKey?: string;
+    baseUrl?: string;
+    /** Sent on every request. Some network layers reject the default user agents of HTTP libraries. */
+    userAgent?: string;
+    /** Custom `fetch`, mainly for tests. Defaults to the global one. */
+    fetch?: FetchLike;
+    /** Retries after a 429 (with `Retry-After`) or a 503. Default 2. */
+    maxRetries?: number;
+    /** Longest `Retry-After` the SDK will sit through, in seconds. Default 30. */
+    retryAfterCapSeconds?: number;
+    /** Per-request timeout in milliseconds. Default 30000. */
+    timeoutMs?: number;
+    /** Replaces the delay between retries, mainly for tests. */
+    sleep?: (ms: number) => Promise<void>;
+}
+/** Quota counters from the `X-RateLimit-*` headers of the last answer. */
+interface RateLimitInfo {
+    limitHour: number | null;
+    remainingHour: number | null;
+    limitDay: number | null;
+    remainingDay: number | null;
+}
+type Query = Record<string, string | number | boolean | undefined | null>;
+declare class HttpClient {
+    #private;
+    /** Quota counters of the most recent answer that carried them. */
+    lastRateLimit: RateLimitInfo | null;
+    private readonly baseUrl;
+    private readonly userAgent;
+    private readonly fetchImpl;
+    private readonly maxRetries;
+    private readonly capSeconds;
+    private readonly timeoutMs;
+    private readonly sleep;
+    constructor(options?: ClientOptions);
+    url(path: string, query?: Query): string;
+    /**
+     * GET `path` and return the parsed JSON body; throws a typed error otherwise. `isPublic`
+     * marks the two endpoints the server answers without a key; everything else needs one.
+     * `accept` lets a caller treat a non-2xx body as data (see `health()`).
+     */
+    get<T>(path: string, query?: Query, options?: {
+        isPublic?: boolean;
+        accept?: (body: unknown) => boolean;
+    }): Promise<T>;
+    private shouldRetry;
+    private send;
+    /** Masked form: the only representation of this object that logging or serializing can reach. */
+    toJSON(): {
+        baseUrl: string;
+        userAgent: string;
+        apiKey: string | null;
+    };
+    private trackQuota;
+}
+
+interface ImageUrlOptions {
+    baseUrl?: string;
+    /** Pokémon only: `low` (default) or `high`. */
+    size?: 'low' | 'high';
+    /** Pokémon only: localized render (`it`, `fr`, `de`, `es`, `pt`). */
+    lang?: string;
+    /** Pokémon only: set code, to disambiguate a plain card number. */
+    set?: string;
+}
+/**
+ * Builds the image URL of a card from its id. Pure string work: nothing is fetched.
+ *
+ * The image routes are protected like every other route: the request MUST carry the
+ * `X-API-Key` header, so the URL cannot be used directly in an `<img>` tag. Fetch it
+ * yourself with the header, or proxy it server-side.
+ */
+declare function imageUrl(id: string, options?: ImageUrlOptions): string;
+
+/**
+ * Public, normalized types. Every object keeps the unmodified server value in `raw`.
+ * Prices are `number | null`; the API sometimes sends numeric strings.
+ */
+declare const GAME_CODES: readonly ["mtg", "ygo", "cfv", "dbs", "fab", "dgm", "swu", "lor", "rft", "cpk"];
+type GameCode = (typeof GAME_CODES)[number];
+interface TcgPrice {
+    /** Finish (`Normal`, `Holofoil`, `Foil`...). Null for rows that have no finish. */
+    variant: string | null;
+    low: number | null;
+    mid: number | null;
+    high: number | null;
+    market: number | null;
+    directLow: number | null;
+    updatedAt: string | null;
+    raw: unknown;
+}
+interface CardmarketPrice {
+    variant: string | null;
+    avg: number | null;
+    low: number | null;
+    trend: number | null;
+    avg1: number | null;
+    avg7: number | null;
+    avg30: number | null;
+    updatedAt: string | null;
+    raw: unknown;
+}
+interface Card {
+    /** `pk_…` (Pokémon), `op_…`, `<code>_…`, or a 64-character hex CardMarket id. Reuse as is. */
+    id: string;
+    name: string;
+    cleanName: string | null;
+    number: string | null;
+    rarity: string | null;
+    cardType: string | null;
+    productType: string | null;
+    text: string | null;
+    variants: string[];
+    /**
+     * Set identifiers. `setId` is the numeric id (possibly negative); `setCode` the short code.
+     * Source: `card_info.set_id` / `card_info.set_code`; for cards listed by a set, both come from the
+     * response's `set` object.
+     * One Piece search and detail answers carry neither, so both are null there.
+     */
+    setId: string | null;
+    setCode: string | null;
+    setName: string | null;
+    tcgplayer: {
+        url: string | null;
+        prices: TcgPrice[];
+    } | null;
+    cardmarket: {
+        productName: string | null;
+        url: string | null;
+        prices: CardmarketPrice[];
+    } | null;
+    /** Game-specific fields: `hp`, `attacks`, `p`, `t`, `ext_color`... as sent by the API. */
+    info: Record<string, unknown>;
+    raw: unknown;
+}
+interface SetSummary {
+    /** Numeric set id as a string (`set_id`; `group_id` for One Piece). */
+    id: string;
+    code: string | null;
+    name: string;
+    /** Free text. Pokémon uses `eng`/`jap`/`chn`, One Piece `en`/`jp`. */
+    language: string | null;
+    releaseDate: string | null;
+    cardCount: number | null;
+    sealedCount: number | null;
+    raw: unknown;
+}
+interface Page<T> {
+    items: T[];
+    page: number;
+    limit: number;
+    total: number;
+    /** Computed from `total` and `limit`, so it is always a finite number. */
+    totalPages: number;
+}
+interface SearchPage extends Page<Card> {
+    /** Pokémon and games: the candidate list was cut at its cap, refine the query instead of paging. Always false for One Piece. */
+    truncated: boolean;
+}
+interface SetPage extends Page<Card> {
+    set: SetSummary;
+}
+interface PriceRow {
+    id: string;
+    number: string | null;
+    name: string;
+    variant: string | null;
+    productType: string | null;
+    tcgplayer: TcgPrice | null;
+    cardmarket: CardmarketPrice | null;
+}
+interface SetPrices {
+    source: string;
+    setId: string | null;
+    setCode: string | null;
+    rows: PriceRow[];
+    total: number;
+    raw: unknown;
+}
+interface SetRef {
+    id: string | null;
+    code: string | null;
+    name: string | null;
+}
+interface PriceStats {
+    avg: number | null;
+    min: number | null;
+    max: number | null;
+    mostExpensive: {
+        id: string | null;
+        name: string | null;
+        price: number | null;
+    } | null;
+    trendDirection: string | null;
+}
+interface SetStatistics {
+    set: SetRef & {
+        totalCards: number | null;
+    };
+    tcgplayer: PriceStats | null;
+    cardmarket: PriceStats | null;
+    rarityBreakdown: Record<string, number>;
+    raw: unknown;
+}
+interface CompletionValue {
+    set: SetRef & {
+        totalCards: number | null;
+    };
+    tcgplayer: {
+        currency: string | null;
+        low: number | null;
+        market: number | null;
+        high: number | null;
+    } | null;
+    cardmarket: {
+        currency: string | null;
+        low: number | null;
+        avg: number | null;
+        trend: number | null;
+    } | null;
+    byRarity: Record<string, {
+        count: number;
+        totalCost: number | null;
+    }>;
+    note: string | null;
+    raw: unknown;
+}
+interface TrendingSet {
+    set: SetRef;
+    cardCount: number | null;
+    /** As sent: `+446.7%`. */
+    change: string | null;
+    changePct: number | null;
+    avgPriceCurrent: number | null;
+    avgPricePrevious: number | null;
+    topMovers: Array<{
+        name: string | null;
+        change: string | null;
+    }>;
+    raw: unknown;
+}
+interface TopCard {
+    id: string;
+    name: string;
+    number: string | null;
+    rarity: string | null;
+    setName: string | null;
+    setId: string | null;
+    setCode: string | null;
+    price: number | null;
+    change7d: string | null;
+    raw: unknown;
+}
+interface HistoryPoint {
+    /** Snapshot price keyed by days back: 7, 14, 30, 60, 120. */
+    price: Record<number, number | null>;
+    change: Record<number, string | null>;
+    current: Record<string, number | null>;
+    lastUpdated: string | null;
+}
+interface PriceHistory {
+    id: string;
+    name: string | null;
+    tcgplayer: Record<string, HistoryPoint> | null;
+    cardmarket: Record<string, HistoryPoint> | null;
+    raw: unknown;
+}
+type SearchOptions = {
+    page?: number;
+    limit?: number;
+};
+type SetOptions = {
+    page?: number;
+    limit?: number;
+    language?: string;
+};
+type PricesOptions = {
+    source?: 'tcg' | 'cm';
+};
+type StatisticsOptions = {
+    variant?: 'normal' | 'foil';
+};
+type TrendingOptions = {
+    period?: '7d';
+    limit?: number;
+};
+type TopCardsOptions = {
+    metric?: 'price' | 'growth';
+    source?: 'tcg' | 'cm';
+    limit?: number;
+};
+interface Game {
+    /** Route prefix and `game` code: `mtg`, `ygo`, ... */
+    code: GameCode;
+    name: string;
+    /** Free routes, keyed by role: `sets`, `set`, `card`, `search`, `image`. */
+    endpoints: Record<string, string>;
+    /** Plan-gated routes: `prices`, `statistics`, `completion_value`, `trending`, `top_cards`. */
+    proEndpoints: Record<string, string>;
+    raw: unknown;
+}
+interface HealthCheck {
+    /** `healthy`, `degraded` or `unhealthy`. */
+    status: string;
+    /** Set by the server when the check failed or is limited. */
+    message: string | null;
+    responseTime: number | null;
+}
+interface Health {
+    /** Overall status: `healthy` or `unhealthy`. Only the database and storage are critical. */
+    status: string;
+    timestamp: string | null;
+    version: string | null;
+    /** Per-service checks: `database`, `cache`, `storage`. */
+    checks: Record<string, HealthCheck>;
+    responseTime: number | null;
+    region: string | null;
+    message: string | null;
+    raw: unknown;
+}
+
+/**
+ * The one interface shared by Pokémon, One Piece and the ten games. Where the API
+ * needs a different route, parameter or response shape, the world hides it.
+ *
+ * Plan-gated methods (`prices`, `statistics`, `completionValue`, `trending`, `topCards`)
+ * throw `PlanRequiredError` when the account's plan or trial does not cover them.
+ * An ambiguous set code throws `AmbiguousSetError`; retry with one of its `matches[].setId`.
+ */
+interface World {
+    /** One page of search results. `q` is 2-100 characters for the ten games. */
+    search(q: string, options?: SearchOptions): Promise<SearchPage>;
+    /** Every result of a search, page after page. */
+    searchAll(q: string, options?: {
+        limit?: number;
+        maxItems?: number;
+    }): AsyncGenerator<Card, void, undefined>;
+    /** Card by id (`pk_…`, `op_…`, `<code>_…`, or a 64-hex CardMarket id). */
+    card(id: string): Promise<Card>;
+    /** All sets of the world. The API does not paginate this list. */
+    sets(options?: {
+        language?: string;
+    }): Promise<SetSummary[]>;
+    /** One page of a set's cards. `code` is a set code or a numeric set id. */
+    set(code: string, options?: SetOptions): Promise<SetPage>;
+    /** Every card of a set, page after page. */
+    setCards(code: string, options?: {
+        limit?: number;
+        language?: string;
+        maxItems?: number;
+    }): AsyncGenerator<Card, void, undefined>;
+    /** Prices of every card in a set: hundreds to thousands of rows. */
+    prices(code: string, options?: PricesOptions): Promise<SetPrices>;
+    statistics(code: string, options?: StatisticsOptions): Promise<SetStatistics>;
+    completionValue(code: string): Promise<CompletionValue>;
+    trending(options?: TrendingOptions): Promise<TrendingSet[]>;
+    topCards(options?: TopCardsOptions): Promise<TopCard[]>;
+}
+
+interface CardWorldConfig {
+    /** Route prefix: `''` for Pokémon, `/mtg` for a game. */
+    prefix: string;
+    /** Minimum search length: the games reject queries shorter than 2 characters. */
+    minQuery: number;
+}
+/** Pokémon and the ten games share one response shape, so one class serves them all. */
+declare class CardWorld implements World {
+    protected readonly http: HttpClient;
+    protected readonly config: CardWorldConfig;
+    constructor(http: HttpClient, config: CardWorldConfig);
+    protected path(rest: string): string;
+    search(q: string, options?: SearchOptions): Promise<SearchPage>;
+    searchAll(q: string, options?: {
+        limit?: number;
+        maxItems?: number;
+    }): AsyncGenerator<Card, void, undefined>;
+    card(id: string): Promise<Card>;
+    sets(options?: {
+        language?: string;
+    }): Promise<SetSummary[]>;
+    set(code: string, options?: SetOptions): Promise<SetPage>;
+    setCards(code: string, options?: {
+        limit?: number;
+        language?: string;
+        maxItems?: number;
+    }): AsyncGenerator<Card, void, undefined>;
+    prices(code: string, options?: PricesOptions): Promise<SetPrices>;
+    statistics(code: string, options?: StatisticsOptions): Promise<SetStatistics>;
+    completionValue(code: string): Promise<CompletionValue>;
+    trending(options?: TrendingOptions): Promise<TrendingSet[]>;
+    topCards(options?: TopCardsOptions): Promise<TopCard[]>;
+}
+
+/** Pokémon: the shared card world plus the endpoints only Pokémon has. */
+declare class PokemonWorld extends CardWorld {
+    constructor(http: HttpClient);
+    /**
+     * Card by id, or by plain card number together with `setCode` (`card('086/078', { setCode: 'SV8a' })`).
+     * Ids from `search` and `set` are the safest input.
+     */
+    card(id: string, options?: {
+        setCode?: string;
+    }): Promise<Card>;
+    /** Price snapshots at 7/14/30/60/120 days, per finish (not a time series). Pro or trial. */
+    priceHistory(id: string): Promise<PriceHistory>;
+}
+
+/**
+ * Entry point. One interface for every world:
+ *
+ * ```ts
+ * const pw = new PokeWallet({ apiKey: process.env.POKEWALLET_API_KEY })
+ * await pw.pokemon.search('charizard')
+ * await pw.onepiece.set('OP01')
+ * await pw.games.mtg.search('black lotus')
+ * ```
+ */
+declare class PokeWallet {
+    #private;
+    readonly pokemon: PokemonWorld;
+    readonly onepiece: World;
+    readonly games: Readonly<Record<GameCode, World>>;
+    constructor(options?: ClientOptions);
+    /** Quota counters from the most recent answer, or null before the first call. */
+    get lastRateLimit(): RateLimitInfo | null;
+    /** The world for a game code known only at runtime. */
+    game(code: GameCode): World;
+    /**
+     * Service status. Works without a key; the header is sent only when a key is set.
+     *
+     * The API answers 503 with a full report when a critical service is down. That report is
+     * information, not a failure: it is returned like a 200, with `status: 'unhealthy'` and the
+     * failing `checks`, and is never retried. A 503 without a report (for example an error page
+     * from the edge) still throws `UnavailableError`.
+     */
+    health(): Promise<Health>;
+    /** The ten games with their route maps. Works without a key. */
+    listGames(): Promise<Game[]>;
+    toJSON(): {
+        client: unknown;
+    };
+    /** See {@link imageUrl}: the URL still needs the API key header. */
+    imageUrl(id: string, options?: Omit<ImageUrlOptions, 'baseUrl'>): string;
+}
+
+/**
+ * Walks every page of any list endpoint as one async sequence. The two pagination
+ * shapes of the API are already hidden behind `fetchPage`.
+ */
+declare function paginate<T>(fetchPage: (page: number) => Promise<Page<T>>, options?: {
+    startPage?: number;
+    maxItems?: number;
+}): AsyncGenerator<T, void, undefined>;
+
+/** Hourly or daily quota window as reported in a 429 body. */
+interface LimitWindow {
+    limit: number;
+    used: number;
+    remaining: number;
+}
+interface RateLimitWindows {
+    hourly?: LimitWindow;
+    daily?: LimitWindow;
+}
+/** One candidate of an ambiguous set. `setId` is the value to pass back to pick it. */
+interface SetMatch {
+    setId: string;
+    setCode: string | null;
+    name: string | null;
+    language: string | null;
+    releaseDate: string | null;
+}
+interface ErrorInit {
+    status: number;
+    body?: unknown;
+    message?: string;
+}
+/** Base class of every error raised by the SDK for an API answer. */
+declare class PokeWalletError extends Error {
+    readonly status: number;
+    /** Parsed JSON body of the answer, when there was one. */
+    readonly body: unknown;
+    /** The `error` field of the body, when present. */
+    readonly code: string | undefined;
+    constructor(init: ErrorInit);
+}
+/** Raised before any request when an argument is out of range. */
+declare class ValidationError extends RangeError {
+    constructor(message: string);
+}
+/** The request never produced an HTTP answer (DNS, connection, timeout). */
+declare class NetworkError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** 400: missing or invalid parameter, or an id that cannot be decoded. */
+declare class BadRequestError extends PokeWalletError {
+}
+/** 401: key missing, malformed or unknown. */
+declare class AuthError extends PokeWalletError {
+}
+/**
+ * 403 on a plan-gated endpoint. `redeemUrl` is set when the free trial was never
+ * activated; `upgradeUrl` when the trial expired or the plan is too low.
+ */
+declare class PlanRequiredError extends PokeWalletError {
+    readonly redeemUrl: string | undefined;
+    readonly upgradeUrl: string | undefined;
+    constructor(init: ErrorInit);
+}
+/** 403 `Feature not enabled`: this account does not have access to this feature. */
+declare class FeatureNotEnabledError extends PokeWalletError {
+    readonly contactUrl: string | undefined;
+    constructor(init: ErrorInit);
+}
+/** 404: unknown card, set or route. Carries the server's suggestions when it sent any. */
+declare class NotFoundError extends PokeWalletError {
+    readonly didYouMean: string | undefined;
+    readonly suggestions: unknown[];
+    constructor(init: ErrorInit);
+}
+/** 404 on a game route: the game is switched off for this account. */
+declare class GameUnavailableError extends NotFoundError {
+}
+/**
+ * The set code matches several sets. Unifies the three ways the API says so
+ * (200 with `disambiguation`, 300, 409). Retry with one `matches[i].setId`.
+ */
+declare class AmbiguousSetError extends PokeWalletError {
+    readonly matches: SetMatch[];
+    constructor(init: ErrorInit & {
+        matches: SetMatch[];
+    });
+}
+/**
+ * 429. The API sends no `Retry-After`, so the SDK retries only when the header is
+ * present and within the cap. `limits` mirrors the body: when a window shows
+ * `remaining === 0`, waiting seconds cannot help.
+ */
+declare class RateLimitError extends PokeWalletError {
+    readonly limits: RateLimitWindows;
+    /** Seconds, from the `Retry-After` header, when present. */
+    readonly retryAfter: number | undefined;
+    constructor(init: ErrorInit & {
+        retryAfter?: number;
+    });
+}
+/** 503: database busy or feature not yet enabled. `retryAfter` is 5 or 3600 seconds. */
+declare class UnavailableError extends PokeWalletError {
+    readonly retryAfter: number | undefined;
+    constructor(init: ErrorInit & {
+        retryAfter?: number;
+    });
+}
+/** Any other 5xx. Never retried. */
+declare class ServerError extends PokeWalletError {
+}
+
+declare const VERSION = "0.1.3";
+
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+interface paths {
+    "/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Service status
+         * @description Needs no key. Answers 503 with the same report body (`status: unhealthy`) when the database
+         *     or storage is down; the cache is optional and only degrades the message. A 503 without
+         *     a `status` field is a different failure (edge error, `Retry-After` present).
+         */
+        get: operations["getHealth"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/games": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The ten games and their routes */
+        get: operations["listGames"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Search Pokémon cards by name, number, set or rarity
+         * @description `metadata.truncated` is true when the candidates were cut at 500: a more specific query is needed.
+         *     `page` and `limit`: a missing, non-numeric or lower-than-1 value falls back to the default, and a
+         *     value above the cap (100 for `limit`) is clamped. The SDKs still check both before sending.
+         *     A name may contain parentheses, e.g. `Pikachu (Cosmos Holo)`.
+         */
+        get: operations["pokemonSearch"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** All Pokémon sets (not paginated, long list) */
+        get: operations["pokemonListSets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sets/trending": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Sets with the strongest CardMarket price change (Pro or trial)
+         * @description Same format in every world. Only `period=7d` exists; `30d` answers 400 `Invalid parameter`.
+         */
+        get: operations["pokemonTrendingSets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sets/{setCode}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Cards of a set (paginated)
+         * @description `setCode` is a `set_code` (`PLF`) or a numeric `set_id`, possibly negative (CardMarket-only sets).
+         *
+         *     Ambiguous set code: if the `set_code` exists in several languages the answer is
+         *     **200** with `disambiguation: true` and `matches`; on `/prices/{setCode}` it is **300**, on
+         *     statistics and completion-value it is **409**. Disambiguate with `?language=` or the numeric `set_id`.
+         *
+         *     In this listing `card_info.set_code` and `card_info.set_id` hold the set's real code ("PLF") and
+         *     numeric id ("1382"), the same as in `/cards/{id}` and `/search`; the `set` object carries `set_id` too.
+         *     `prices` is always `[]` here.
+         *
+         *     Note: send `limit` and `page` within range (see `/search`).
+         */
+        get: operations["pokemonGetSet"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sets/{setCode}/statistics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Price and rarity statistics of a set (Pro or trial)
+         * @description Same format in every world: `set_info` is `{name, set_code, set_id, total_cards}` with the real set code;
+         *     `total_cards` counts cards (sealed products excluded), not finishes. `trend_direction` compares the
+         *     7-day with the 30-day average. Ambiguous set: **409**.
+         */
+        get: operations["pokemonSetStatistics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sets/{setCode}/completion-value": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Cost to complete a set (Pro or trial)
+         * @description One copy of each card, in its base finish. `set_info` has the same shape as in statistics.
+         */
+        get: operations["pokemonSetCompletionValue"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/prices/{setCode}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Prices of every card in a set (Pro or trial; hundreds of rows)
+         * @description The response carries both `set_id` and `group_id` (the same value).
+         *     Ambiguous set: **300** with the `Disambiguation` body (no `error` field).
+         */
+        get: operations["pokemonSetPrices"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cards/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Pokémon card detail
+         * @description `id` is `pk_<hex>`, a 64-character hex CardMarket `encrypted_id`, or a plain card number
+         *     (`086`, `086/078`, `010a/073`) to be combined with `set_code`. An id from another game (`op_`, `mtg_`...)
+         *     gives 400 with a hint to the right route.
+         */
+        get: operations["pokemonGetCard"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cards/{id}/price-history": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Price history as fixed snapshots (7/14/30/60/120 days; Pokémon only; Pro or trial) */
+        get: operations["pokemonPriceHistory"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/analytics/top-cards": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Ranking by price or growth (Pro or trial)
+         * @description Same item format in every world: `{id, card_info, current_price, change_7d?}` (`change_7d` only for growth).
+         *     `card_info` is the full common card info. Price ranking uses the TCGPlayer market price (`tcg`) or the
+         *     CardMarket trend price (`cm`). A CardMarket row linked to a TCGPlayer card carries that card's `pk_` id,
+         *     the others the CardMarket encrypted id; both open with `/cards/{id}`. Growth with `source=tcg` exists
+         *     for Pokémon only.
+         */
+        get: operations["pokemonTopCards"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/op/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Search One Piece cards
+         * @description Flat pagination `{data,total,page,limit}` (differs from Pokémon, which nests it in `pagination`).
+         *     `page` and `limit`: a missing, non-numeric or lower-than-1 value falls back to the default, and a
+         *     value above the cap is clamped. A name may contain parentheses, e.g. `Buggy (Reprint)`.
+         */
+        get: operations["opSearch"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/op/sets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * All One Piece sets
+         * @description The set identifier is called `group_id` here (`set_id` elsewhere).
+         */
+        get: operations["opListSets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/op/sets/trending": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Sets with the strongest CardMarket price change (Pro or trial) */
+        get: operations["opTrendingSets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/op/sets/{set}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Cards of a One Piece set (paginated, flat shape)
+         * @description `set` is a `set_code` (`OP01`, `EB01` also without the hyphen) or a numeric `group_id` (possibly negative).
+         *     No disambiguation: if several sets share a code the first one wins.
+         */
+        get: operations["opGetSet"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/op/sets/{set}/statistics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Statistics of a set (Pro or trial) */
+        get: operations["opSetStatistics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/op/sets/{set}/completion-value": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Cost to complete a set (Pro or trial) */
+        get: operations["opSetCompletionValue"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/op/cards/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * One Piece card detail
+         * @description `id` is `op_<hex>`. Flat card, with `success` and without `card_info` (differs from Pokémon).
+         */
+        get: operations["opGetCard"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/op/prices": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Prices of every card in a set (Pro or trial)
+         * @description The set goes in the query (`set_code` or `group_id`), not in the path as on other routes.
+         *     At least one of the two is required, otherwise 400.
+         *     Like the other worlds, the response has `source`, `set_code`, `set_id` and a `product_type` on every row.
+         */
+        get: operations["opSetPrices"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/op/analytics/top-cards": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Ranking by price or growth (Pro or trial)
+         * @description `metric=growth` requires `source=cm` (with `tcg` it gives 400 `Not available yet`).
+         */
+        get: operations["opTopCards"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/{game}/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Search the cards of a game
+         * @description `q` must be 2-100 characters. `limit`/`page` are validated (invalid values fall back to defaults).
+         *     `metadata.truncated` means the search stopped at its cap: a more specific query is needed.
+         */
+        get: operations["gameSearch"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/{game}/sets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * All sets of a game
+         * @description `set_code` can be `null`. `card_count`/`sealed_count` are missing if the SQL counts function is not installed.
+         */
+        get: operations["gameListSets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/{game}/sets/trending": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Trending sets (Ultra or trial) */
+        get: operations["gameTrendingSets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/{game}/sets/{set}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Cards of a set (paginated)
+         * @description `set` is a `set_code` or a `set_id`. Ambiguous set: **200** with `disambiguation: true`
+         *     (the Pro routes answer 409). The listing exposes no prices (`prices: []`).
+         */
+        get: operations["gameGetSet"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/{game}/sets/{set}/statistics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Statistics of a set (Ultra or trial) */
+        get: operations["gameSetStatistics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/{game}/sets/{set}/completion-value": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Cost to complete a set (Ultra or trial) */
+        get: operations["gameSetCompletionValue"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/{game}/prices/{set}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Prices of every card in a set (Ultra or trial; up to thousands of rows) */
+        get: operations["gameSetPrices"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/{game}/cards/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Card detail
+         * @description `id` is `<code>_<hex>` or a 64-character hex CardMarket `encrypted_id` (CardMarket-only cards).
+         */
+        get: operations["gameGetCard"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/{game}/analytics/top-cards": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Ranking by price or growth (Ultra or trial)
+         * @description `metric=growth` requires `source=cm` (with `tcg` it gives 400 `Not available yet`).
+         */
+        get: operations["gameTopCards"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+interface components {
+    schemas: {
+        /** @enum {string} */
+        GameCode: "mtg" | "ygo" | "cfv" | "dbs" | "fab" | "dgm" | "swu" | "lor" | "rft" | "cpk";
+        Nullable_Number: number | null;
+        /** @description Union of all error shapes; only `error` is always present. */
+        ApiError: {
+            error: string;
+            message?: string;
+            /** Format: uri */
+            docs?: string;
+            example?: string;
+            did_you_mean?: string;
+            /** Format: uri */
+            redeem_url?: string;
+            /** Format: uri */
+            upgrade_url?: string;
+            /** Format: uri */
+            contact_url?: string;
+            suggestions?: {
+                [key: string]: unknown;
+            }[];
+            /** @description Candidates of an ambiguous set; the fields vary (the Pokémon set-image route sends only `set_id` and `language`). */
+            matches?: components["schemas"]["SetMatch"][];
+        } & {
+            [key: string]: unknown;
+        };
+        RateLimitError: components["schemas"]["ApiError"] & {
+            limits?: {
+                hourly?: components["schemas"]["LimitWindow"];
+                daily?: components["schemas"]["LimitWindow"];
+            };
+        };
+        LimitWindow: {
+            limit: number;
+            used: number;
+            remaining: number;
+        };
+        HealthCheck: {
+            /** @enum {string} */
+            status: "healthy" | "degraded" | "unhealthy" | "unknown";
+            responseTime?: number | null;
+            /** @description Present when the check failed or is limited. */
+            message?: string;
+        };
+        Health: {
+            /** @enum {string} */
+            status: "healthy" | "unhealthy";
+            /** Format: date-time */
+            timestamp?: string;
+            version?: string;
+            /** @description Keys are `database`, `cache` and `storage`. */
+            checks?: {
+                [key: string]: components["schemas"]["HealthCheck"];
+            };
+            responseTime?: number;
+            region?: string;
+            /** @description Present when degraded or unhealthy. */
+            message?: string;
+        };
+        GamesResponse: {
+            success: boolean;
+            data: {
+                code: components["schemas"]["GameCode"];
+                name: string;
+                endpoints: {
+                    [key: string]: string;
+                };
+                pro_endpoints: {
+                    [key: string]: string;
+                };
+            }[];
+        };
+        TcgplayerPrice: {
+            low_price?: components["schemas"]["Nullable_Number"];
+            mid_price?: components["schemas"]["Nullable_Number"];
+            high_price?: components["schemas"]["Nullable_Number"];
+            market_price?: components["schemas"]["Nullable_Number"];
+            direct_low_price?: components["schemas"]["Nullable_Number"];
+            /** @description ISO 8601; with or without offset (`+00:00`) depending on the family. */
+            updated_at?: string | null;
+        };
+        /** @description TCGPlayer finish (Pokémon and games). */
+        TcgplayerVariantPrice: components["schemas"]["TcgplayerPrice"] & {
+            /** @description Normal, Holofoil, Reverse Holofoil, Foil... */
+            sub_type_name?: string;
+        };
+        /** @description Prices in EUR. */
+        CardmarketPrice: {
+            avg?: components["schemas"]["Nullable_Number"];
+            low?: components["schemas"]["Nullable_Number"];
+            trend?: components["schemas"]["Nullable_Number"];
+            avg1?: components["schemas"]["Nullable_Number"];
+            avg7?: components["schemas"]["Nullable_Number"];
+            avg30?: components["schemas"]["Nullable_Number"];
+            updated_at?: string | null;
+        };
+        CardmarketVariantPrice: components["schemas"]["CardmarketPrice"] & {
+            /** @description normal, holo, foil... */
+            variant_type?: string;
+        };
+        /**
+         * @description Common fields. The ten games add their own fields in snake_case (`mtg`: `p`,`t`,`sub_type`;
+         *     `ygo`: `attack`,`defense`...). `set_code` is the set's real code and `set_id` its numeric id,
+         *     also in Pokémon set listings; `card_text` and `card_type` are often `null`.
+         */
+        CardInfo: {
+            name: string;
+            clean_name?: string | null;
+            set_name?: string | null;
+            set_code?: string | null;
+            set_id?: string | null;
+            card_number?: string | null;
+            rarity?: string | null;
+            card_type?: string | null;
+            /** @description `card` or sealed product. */
+            product_type?: string | null;
+            /** @description Finishes, `Normal` first, then alphabetical. Present in Pokémon search and detail too. */
+            variants?: string[];
+            card_text?: string | null;
+            hp?: string | null;
+            stage?: string | null;
+            attacks?: string[];
+            weakness?: string | null;
+            resistance?: string | null;
+            retreat_cost?: string | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description `id` is `pk_<hex>`, `<code>_<hex>` or a 64-character hex CardMarket `encrypted_id` (CardMarket-only cards). */
+        Card: {
+            id: string;
+            card_info: components["schemas"]["CardInfo"];
+            images?: {
+                languages?: string[];
+            };
+            tcgplayer?: {
+                prices?: components["schemas"]["TcgplayerVariantPrice"][];
+                url?: string;
+            } | null;
+            cardmarket?: {
+                product_name?: string | null;
+                prices?: components["schemas"]["CardmarketVariantPrice"][];
+                product_url?: string;
+            } | null;
+        };
+        Pagination: {
+            page: number;
+            limit: number;
+            total: number;
+            /** @description Pokémon with `limit=0`: `Infinity` becomes `null` in JSON. */
+            total_pages: number | null;
+        };
+        SearchResponse: {
+            query: string;
+            results: components["schemas"]["Card"][];
+            pagination: components["schemas"]["Pagination"];
+            metadata?: {
+                total_count?: number;
+                tcg?: number;
+                cardmarket?: number;
+                tcg_only?: number;
+                cardmarket_only?: number;
+                both_sources?: number;
+                /** @description True when the candidate list was cut at its cap (500 for Pokémon): use a more specific query. */
+                truncated?: boolean;
+            };
+        };
+        SetListEntry: {
+            name: string;
+            set_code?: string | null;
+            /** @description Numeric, as a string, possibly negative (CardMarket-only). */
+            set_id: string;
+            card_count?: number;
+            sealed_count?: number;
+            /** @description Pokémon only. */
+            number_count?: number;
+            language?: string | null;
+            /** @description Pokémon: `3rd August, 2007`; games: ISO 8601. */
+            release_date?: string | null;
+        };
+        SetListResponse: {
+            success: boolean;
+            data: components["schemas"]["SetListEntry"][];
+            total: number;
+        };
+        SetDetail: {
+            name: string;
+            set_code?: string | null;
+            set_id: string;
+            total_cards?: number;
+            language?: string | null;
+            release_date?: string | null;
+        };
+        SetCardsResponse: {
+            success: boolean;
+            set: components["schemas"]["SetDetail"];
+            cards: components["schemas"]["Card"][];
+            pagination: components["schemas"]["Pagination"];
+        };
+        SetMatch: {
+            set_id?: string;
+            set_code?: string | null;
+            name?: string;
+            language?: string | null;
+            release_date?: string | null;
+        };
+        Disambiguation: {
+            /** @constant */
+            disambiguation: true;
+            /** @enum {string} */
+            ambiguity?: "set";
+            message?: string;
+            matches: components["schemas"]["SetMatch"][];
+            total?: number;
+        };
+        PriceRow: {
+            id: string;
+            card_number?: string | null;
+            name: string;
+            variant?: string | null;
+            product_type?: string;
+            tcgplayer?: components["schemas"]["TcgplayerPrice"] | null;
+            cardmarket?: components["schemas"]["CardmarketPrice"] | null;
+        };
+        /** @description Carries both `set_id` and `group_id` (the same value). */
+        PokemonPricesResponse: {
+            success?: boolean;
+            /** @enum {string} */
+            source?: "both" | "tcg" | "cm";
+            set_code?: string | null;
+            set_id?: string;
+            group_id?: string;
+            data?: components["schemas"]["PriceRow"][];
+            total?: number;
+        };
+        GamePricesResponse: {
+            success?: boolean;
+            /** @enum {string} */
+            source?: "both" | "tcg" | "cm";
+            set_code?: string | null;
+            set_id?: string;
+            data?: components["schemas"]["PriceRow"][];
+            total?: number;
+        };
+        StatisticsResponse: {
+            /** @description Same in every world. */
+            set_info: {
+                name?: string;
+                /** @description The real set code. */
+                set_code?: string | null;
+                set_id?: string;
+                /** @description Cards, not finishes; sealed products excluded. */
+                total_cards?: number;
+            };
+            price_statistics: {
+                tcgplayer?: components["schemas"]["PriceStats"];
+                cardmarket?: components["schemas"]["PriceStats"];
+            };
+            rarity_breakdown: {
+                [key: string]: number;
+            };
+        };
+        PriceStats: ({
+            /** @description A string (`"25.92"`), unlike the other prices. */
+            avg_market_price?: string;
+            avg_price?: string;
+            min_price?: number;
+            max_price?: number;
+            most_expensive?: {
+                id?: string;
+                name?: string;
+                price?: number;
+            };
+            /** @enum {string} */
+            trend_direction?: "up" | "down" | "stable";
+        } & {
+            [key: string]: unknown;
+        }) | null;
+        CompletionValueResponse: {
+            set_info: {
+                name?: string;
+                set_code?: string | null;
+                set_id?: string;
+                total_cards?: number;
+            };
+            completion_cost: {
+                tcgplayer?: {
+                    currency?: string;
+                    low_estimate?: number;
+                    market_estimate?: number;
+                    high_estimate?: number;
+                };
+                cardmarket?: {
+                    currency?: string;
+                    low_estimate?: number;
+                    avg_estimate?: number;
+                    trend_estimate?: number;
+                };
+                note?: string;
+            };
+            breakdown_by_rarity: {
+                [key: string]: {
+                    count?: number;
+                    total_cost?: number;
+                };
+            };
+        };
+        TrendingResponse: {
+            period: string;
+            trending_sets: {
+                set_name?: string | null;
+                set_code?: string | null;
+                set_id?: string;
+                card_count?: number;
+                cardmarket?: {
+                    /** @description `+446.7%` */
+                    price_change?: string;
+                    avg_price_current?: number;
+                    avg_price_previous?: number;
+                    top_movers?: {
+                        name?: string | null;
+                        change?: string;
+                    }[];
+                };
+                /** @description `{status, message}` (TCGPlayer history is not available yet) or `null`. */
+                tcgplayer?: {
+                    [key: string]: unknown;
+                } | null;
+            }[];
+        };
+        TopCardsResponse: {
+            /** @enum {string} */
+            metric: "price" | "growth";
+            /** @enum {string} */
+            source: "tcg" | "cm";
+            top_cards: {
+                id: string;
+                card_info: components["schemas"]["CardInfo"];
+                current_price: number;
+                change_7d?: string;
+            }[];
+        };
+        PriceHistory: {
+            id: string;
+            card_name?: string | null;
+            tcgplayer?: components["schemas"]["HistorySide"];
+            cardmarket?: components["schemas"]["HistorySide"];
+        };
+        /** @description Per finish, as fixed snapshots (not a time series). The keys of `variants` are the finish names. */
+        HistorySide: {
+            variants?: {
+                [key: string]: {
+                    current?: {
+                        [key: string]: number | null;
+                    };
+                    price_7d?: number | null;
+                    price_14d?: number | null;
+                    price_30d?: number | null;
+                    price_60d?: number | null;
+                    price_120d?: number | null;
+                    change_7d?: string | null;
+                    change_14d?: string | null;
+                    change_30d?: string | null;
+                    change_60d?: string | null;
+                    change_120d?: string | null;
+                    last_updated?: string | null;
+                } & {
+                    [key: string]: unknown;
+                };
+            };
+        } | null;
+        /** @description Flat card: no `card_info`, `ext_*` fields; `prices` is a single object (Pokémon: an array per finish). CardMarket prices are attached to the cards of the English sets too (OP15, OP14, PRB-02, EB04), so more search and detail answers carry a `cardmarket` block. */
+        OpCard: {
+            /** @description `op_<hex>` */
+            id: string;
+            card_number?: string | null;
+            name: string;
+            clean_name?: string | null;
+            sub_type_name?: string | null;
+            rarity?: string | null;
+            card_type?: string | null;
+            ext_color?: string | null;
+            ext_cost?: string | null;
+            ext_power?: string | null;
+            /** @description Separated by `;`. */
+            ext_subtypes?: string | null;
+            ext_attribute?: string | null;
+            ext_life?: string | null;
+            ext_counterplus?: string | null;
+            ext_description?: string | null;
+            tcgplayer?: {
+                url?: string;
+                prices?: components["schemas"]["TcgplayerPrice"] | null;
+            } | null;
+            cardmarket?: {
+                product_name?: string | null;
+                product_url?: string;
+                prices?: components["schemas"]["CardmarketPrice"] | null;
+            } | null;
+        };
+        OpCardDetail: {
+            success?: boolean;
+        } & components["schemas"]["OpCard"];
+        /** @description Flat pagination: `total`, `page`, `limit` next to `data`. */
+        OpCardList: {
+            success: boolean;
+            data: components["schemas"]["OpCard"][];
+            total: number;
+            page: number;
+            limit: number;
+        };
+        OpSetEntry: {
+            name?: string;
+            set_code?: string;
+            /** @description Numeric, as a string or a number, possibly negative. */
+            group_id?: string;
+            language?: string | null;
+            release_date?: string | null;
+        };
+        OpSetListResponse: {
+            success?: boolean;
+            data?: components["schemas"]["OpSetEntry"][];
+            total?: number;
+        };
+        OpSetCardsResponse: components["schemas"]["OpCardList"] & {
+            set?: components["schemas"]["OpSetEntry"];
+        };
+        OpPricesResponse: {
+            success?: boolean;
+            /** @enum {string} */
+            source?: "both" | "tcg" | "cm";
+            set_code?: string | null;
+            set_id?: string;
+            group_id?: string | number;
+            data?: components["schemas"]["PriceRow"][];
+            total?: number;
+        };
+    };
+    responses: {
+        /**
+         * @description Missing or invalid parameter. A bad parameter value answers `{error: 'Invalid parameter', message, docs}`
+         *     in every world. Other 400 bodies may carry only `{error}`.
+         */
+        BadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /** @description Missing or invalid key (also a key sent in the query string). */
+        Unauthorized: {
+            headers: {
+                "X-RateLimit-Limit-Hour": components["headers"]["RateLimitLimitHour"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /**
+         * @description Insufficient plan: `Trial not activated` (with `redeem_url`), `Pro plan required` /
+         *     `Ultra plan required` (trial expired, with `upgrade_url`) or `Feature not enabled`
+         *     (this account does not have access to this feature, with `contact_url`).
+         */
+        Forbidden: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /**
+         * @description Missing resource or route. Minimal shape `{error}` (Pokémon/OP) or full with `message`,
+         *     `docs`, `did_you_mean`, `suggestions`. A route of a game that is switched off gives 404.
+         */
+        NotFound: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /** @description Ambiguous set (or card number). Pick with the `set_id` of one of the `matches`. */
+        AmbiguousSet: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /**
+         * @description Hourly or daily limit exhausted. The answer carries no `Retry-After` and no
+         *     `X-RateLimit-Reset`; the waiting time is not declared.
+         */
+        TooManyRequests: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["RateLimitError"];
+            };
+        };
+        /** @description Database busy or feature not yet enabled. Has `Retry-After` (5 or 3600). */
+        Unavailable: {
+            headers: {
+                "Retry-After": components["headers"]["RetryAfter"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /**
+         * @description Internal error. The body is `{error}`; the text is generic for the ten games and may be
+         *     more specific for Pokémon and One Piece.
+         */
+        ServerError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+    };
+    parameters: {
+        Game: components["schemas"]["GameCode"];
+        /** @description `set_code` (`PLF`) or numeric `set_id`, possibly negative. */
+        SetCode: string;
+        /** @description Missing, non-numeric or lower than 1 falls back to 1. */
+        Page: number;
+        /** @description `normal` or `foil`; anything else gives 400 `Invalid parameter`. On Pokémon `holo` is still accepted as a legacy alias of `foil`. */
+        Variant: "normal" | "foil";
+        /** @description Set language (`eng`, `jap`, `chn`, `en`, `jp`...): the vocabulary is not uniform between Pokémon and One Piece. */
+        Language: string;
+        Metric: "price" | "growth";
+        Source: "tcg" | "cm";
+    };
+    requestBodies: never;
+    headers: {
+        /** @description Requests allowed per hour */
+        RateLimitLimitHour: number;
+        /** @description Requests left in the hour */
+        RateLimitRemainingHour: number;
+        /** @description Requests allowed per day */
+        RateLimitLimitDay: number;
+        /** @description Requests left today */
+        RateLimitRemainingDay: number;
+        /** @description Seconds to wait. Present only on 503 (values 5 or 3600), never on 429. */
+        RetryAfter: number;
+    };
+    pathItems: never;
+}
+interface operations {
+    getHealth: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Healthy */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Health"];
+                };
+            };
+            /** @description A critical service is down; the body is still a health report */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Health"];
+                };
+            };
+        };
+    };
+    listGames: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GamesResponse"];
+                };
+            };
+        };
+    };
+    pokemonSearch: {
+        parameters: {
+            query: {
+                q: string;
+                /** @description Missing, non-numeric or lower than 1 falls back to 1. */
+                page?: components["parameters"]["Page"];
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SearchResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    pokemonListSets: {
+        parameters: {
+            query?: {
+                /** @description Set language (`eng`, `jap`, `chn`, `en`, `jp`...): the vocabulary is not uniform between Pokémon and One Piece. */
+                language?: components["parameters"]["Language"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SetListResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    pokemonTrendingSets: {
+        parameters: {
+            query?: {
+                /** @description Only 7d (30d gives 400). */
+                period?: "7d";
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TrendingResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    pokemonGetSet: {
+        parameters: {
+            query?: {
+                /** @description Missing, non-numeric or lower than 1 falls back to 1. */
+                page?: components["parameters"]["Page"];
+                limit?: number;
+                /** @description Set language (`eng`, `jap`, `chn`, `en`, `jp`...): the vocabulary is not uniform between Pokémon and One Piece. */
+                language?: components["parameters"]["Language"];
+            };
+            header?: never;
+            path: {
+                /** @description `set_code` (`PLF`) or numeric `set_id`, possibly negative. */
+                setCode: components["parameters"]["SetCode"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Cards of the set, or the list of candidate sets */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SetCardsResponse"] | components["schemas"]["Disambiguation"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    pokemonSetStatistics: {
+        parameters: {
+            query?: {
+                /** @description `normal` or `foil`; anything else gives 400 `Invalid parameter`. On Pokémon `holo` is still accepted as a legacy alias of `foil`. */
+                variant?: components["parameters"]["Variant"];
+            };
+            header?: never;
+            path: {
+                /** @description `set_code` (`PLF`) or numeric `set_id`, possibly negative. */
+                setCode: components["parameters"]["SetCode"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StatisticsResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["AmbiguousSet"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    pokemonSetCompletionValue: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description `set_code` (`PLF`) or numeric `set_id`, possibly negative. */
+                setCode: components["parameters"]["SetCode"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CompletionValueResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["AmbiguousSet"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    pokemonSetPrices: {
+        parameters: {
+            query?: {
+                source?: "tcg" | "cm";
+            };
+            header?: never;
+            path: {
+                /** @description `set_code` (`PLF`) or numeric `set_id`, possibly negative. */
+                setCode: components["parameters"]["SetCode"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PokemonPricesResponse"];
+                };
+            };
+            /** @description Ambiguous set */
+            300: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Disambiguation"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    pokemonGetCard: {
+        parameters: {
+            query?: {
+                /** @description Disambiguates a plain card number. */
+                set_code?: string;
+            };
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Card"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    pokemonPriceHistory: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PriceHistory"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    pokemonTopCards: {
+        parameters: {
+            query?: {
+                metric?: components["parameters"]["Metric"];
+                source?: components["parameters"]["Source"];
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TopCardsResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    opSearch: {
+        parameters: {
+            query: {
+                q: string;
+                /** @description Missing, non-numeric or lower than 1 falls back to 1. */
+                page?: components["parameters"]["Page"];
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpCardList"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    opListSets: {
+        parameters: {
+            query?: {
+                /** @description Set language (`eng`, `jap`, `chn`, `en`, `jp`...): the vocabulary is not uniform between Pokémon and One Piece. */
+                language?: components["parameters"]["Language"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpSetListResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    opTrendingSets: {
+        parameters: {
+            query?: {
+                /** @description Only 7d (30d gives 400). */
+                period?: "7d";
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TrendingResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    opGetSet: {
+        parameters: {
+            query?: {
+                /** @description Missing, non-numeric or lower than 1 falls back to 1. */
+                page?: components["parameters"]["Page"];
+                limit?: number;
+            };
+            header?: never;
+            path: {
+                set: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpSetCardsResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    opSetStatistics: {
+        parameters: {
+            query?: {
+                /** @description `normal` or `foil`; anything else gives 400 `Invalid parameter`. On Pokémon `holo` is still accepted as a legacy alias of `foil`. */
+                variant?: components["parameters"]["Variant"];
+            };
+            header?: never;
+            path: {
+                set: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StatisticsResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    opSetCompletionValue: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                set: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CompletionValueResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    opGetCard: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpCardDetail"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    opSetPrices: {
+        parameters: {
+            query?: {
+                set_code?: string;
+                group_id?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpPricesResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    opTopCards: {
+        parameters: {
+            query?: {
+                metric?: components["parameters"]["Metric"];
+                source?: components["parameters"]["Source"];
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TopCardsResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    gameSearch: {
+        parameters: {
+            query: {
+                q: string;
+                /** @description Missing, non-numeric or lower than 1 falls back to 1. */
+                page?: components["parameters"]["Page"];
+                limit?: number;
+            };
+            header?: never;
+            path: {
+                game: components["parameters"]["Game"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SearchResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    gameListSets: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                game: components["parameters"]["Game"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SetListResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    gameTrendingSets: {
+        parameters: {
+            query?: {
+                /** @description Only 7d (30d gives 400). */
+                period?: "7d";
+                limit?: number;
+            };
+            header?: never;
+            path: {
+                game: components["parameters"]["Game"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TrendingResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    gameGetSet: {
+        parameters: {
+            query?: {
+                /** @description Missing, non-numeric or lower than 1 falls back to 1. */
+                page?: components["parameters"]["Page"];
+                limit?: number;
+            };
+            header?: never;
+            path: {
+                game: components["parameters"]["Game"];
+                set: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Cards of the set, or the list of candidate sets */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SetCardsResponse"] | components["schemas"]["Disambiguation"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    gameSetStatistics: {
+        parameters: {
+            query?: {
+                /** @description `normal` or `foil`; anything else gives 400 `Invalid parameter`. On Pokémon `holo` is still accepted as a legacy alias of `foil`. */
+                variant?: components["parameters"]["Variant"];
+            };
+            header?: never;
+            path: {
+                game: components["parameters"]["Game"];
+                set: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StatisticsResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["AmbiguousSet"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    gameSetCompletionValue: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                game: components["parameters"]["Game"];
+                set: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CompletionValueResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["AmbiguousSet"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    gameSetPrices: {
+        parameters: {
+            query?: {
+                source?: "tcg" | "cm";
+            };
+            header?: never;
+            path: {
+                game: components["parameters"]["Game"];
+                set: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GamePricesResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["AmbiguousSet"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    gameGetCard: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                game: components["parameters"]["Game"];
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Card"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+            500: components["responses"]["ServerError"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    gameTopCards: {
+        parameters: {
+            query?: {
+                metric?: components["parameters"]["Metric"];
+                source?: components["parameters"]["Source"];
+                limit?: number;
+            };
+            header?: never;
+            path: {
+                game: components["parameters"]["Game"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description Requests allowed per hour */
+                    "X-RateLimit-Limit-Hour"?: number;
+                    /** @description Requests left in the hour */
+                    "X-RateLimit-Remaining-Hour"?: number;
+                    /** @description Requests allowed per day */
+                    "X-RateLimit-Limit-Day"?: number;
+                    /** @description Requests left today */
+                    "X-RateLimit-Remaining-Day"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TopCardsResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            429: components["responses"]["TooManyRequests"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+}
+
+export { AmbiguousSetError, AuthError, BadRequestError, FeatureNotEnabledError, GAME_CODES, GameUnavailableError, NetworkError, NotFoundError, PlanRequiredError, PokeWallet, PokeWalletError, PokemonWorld, RateLimitError, ServerError, UnavailableError, VERSION, ValidationError, imageUrl, paginate };
+export type { Card, CardmarketPrice, ClientOptions, CompletionValue, ErrorInit, FetchLike, Game, GameCode, Health, HealthCheck, HistoryPoint, ImageUrlOptions, LimitWindow, Page, PriceHistory, PriceRow, PriceStats, PricesOptions, RateLimitInfo, RateLimitWindows, SearchOptions, SearchPage, SetMatch, SetOptions, SetPage, SetPrices, SetRef, SetStatistics, SetSummary, StatisticsOptions, TcgPrice, TopCard, TopCardsOptions, TrendingOptions, TrendingSet, World, components, operations, paths };