@ankinize/sdk 0.0.0-stage → 0.1.0

package/dist/gen/types.gen.d.ts

@@ -0,0 +1,3452 @@
+export type ClientOptions = {
+    baseUrl: `${string}://${string}` | (string & {});
+};
+export type Deck = {
+    /**
+     * Numeric id. Stable for the life of the deck.
+     */
+    id: number;
+    /**
+     * Full path, with `::` between parent and child.
+     */
+    name: string;
+};
+export type CreateDeckInput = {
+    /**
+     * Deck name. Use `::` to nest it.
+     */
+    name: string;
+};
+export type RenameDeckInput = {
+    /**
+     * The new full name.
+     */
+    name: string;
+};
+export type Note = {
+    /**
+     * Numeric id. Stable for the life of the note.
+     */
+    id: number;
+    /**
+     * Globally unique id. Anki uses it to tell whether an imported note is the same one.
+     */
+    guid: string;
+    /**
+     * The note type this note was made with.
+     */
+    notetypeId: number;
+    /**
+     * When the note last changed, in seconds since 1970.
+     */
+    mtime?: number;
+    /**
+     * Update sequence number used by sync. `-1` means changed here and not yet synced.
+     */
+    usn?: number;
+    /**
+     * Tags on the note.
+     */
+    tags: Array<string>;
+    /**
+     * Every field's content, keyed by the field's key (its name in camelCase, such as `backExtra`), in the order of the note type's fields. May contain HTML.
+     */
+    fields: {
+        [key: string]: string;
+    };
+};
+export type NoteDetails = Note & {
+    cards?: Array<GeneratedCard>;
+};
+export type CreateNoteInput = {
+    /**
+     * Which note type to use, by name (ignoring case). Send this or `notetypeId`.
+     */
+    notetypeName?: string;
+    /**
+     * Which note type to use, by id. See [List note types](#listNoteTypes). Send this or `notetypeName`.
+     */
+    notetypeId?: number;
+    /**
+     * The deck that receives the new cards, by name (ignoring case), such as `Languages::German`. Send this or `deckId`.
+     */
+    deckName?: string;
+    /**
+     * The deck that receives the new cards, by id. Without a deck the note goes to the `Default` deck.
+     */
+    deckId?: number;
+    /**
+     * The field contents, keyed by each field's key: its name in camelCase (`Back Extra` is `backExtra`) or its exact name. Fields left out are empty. HTML is allowed.
+     */
+    fields: {
+        [key: string]: string;
+    };
+    /**
+     * Tags to put on the note.
+     */
+    tags?: Array<string>;
+    /**
+     * Optional. Only set it to keep an identity from another system.
+     */
+    guid?: string;
+};
+export type Tag = {
+    /**
+     * The tag, spelled as it is stored.
+     */
+    name: string;
+    /**
+     * How many notes carry this tag or a tag nested under it.
+     */
+    noteCount: number;
+};
+export type CreateTagInput = {
+    /**
+     * The tag, with `::` for nesting. It can not contain a space or have an empty part.
+     */
+    name: string;
+};
+export type CreatedTag = {
+    /**
+     * The tag, spelled as it is stored.
+     */
+    name: string;
+    /**
+     * `false` when the tag already existed.
+     */
+    created: boolean;
+};
+export type RenameTagInput = {
+    /**
+     * The new name. If it is already a tag, the two are merged.
+     */
+    newName: string;
+};
+export type RenamedTag = {
+    /**
+     * The tag's new name, as stored.
+     */
+    name: string;
+    /**
+     * How many notes were changed.
+     */
+    notes: number;
+};
+export type CreateTagsBatchInput = {
+    /**
+     * The tags to create, 1 to 200.
+     */
+    names: Array<string>;
+    /**
+     * Write all or nothing. See [Create many notes](#createNotesBatch).
+     */
+    atomic?: boolean;
+};
+export type CreateTagsBatchResult = {
+    /**
+     * Echoes the request.
+     */
+    atomic: boolean;
+    /**
+     * Whether anything was written.
+     */
+    committed: boolean;
+    /**
+     * How many tags were new.
+     */
+    created: number;
+    /**
+     * How many entries were refused.
+     */
+    failed: number;
+    /**
+     * One entry per name sent, in order.
+     */
+    results: Array<CreateTagsBatchItem>;
+};
+export type CreateTagsBatchItem = {
+    index: number;
+    ok: boolean;
+    name?: string;
+    /**
+     * `false` when the tag already existed.
+     */
+    created?: boolean;
+    error?: ItemError;
+};
+export type UpdateTagsBatchInput = {
+    /**
+     * The renames, 1 to 200.
+     */
+    updates: Array<UpdateTagsBatchEntry>;
+    /**
+     * Write all or nothing. See [Create many notes](#createNotesBatch).
+     */
+    atomic?: boolean;
+};
+export type UpdateTagsBatchEntry = {
+    /**
+     * The tag to rename.
+     */
+    name: string;
+    /**
+     * Its new name.
+     */
+    newName: string;
+};
+export type UpdateTagsBatchResult = {
+    atomic: boolean;
+    /**
+     * Whether anything was written.
+     */
+    committed: boolean;
+    /**
+     * How many tags were renamed.
+     */
+    renamed: number;
+    /**
+     * How many entries were refused.
+     */
+    failed: number;
+    /**
+     * One entry per update sent, in order.
+     */
+    results: Array<UpdateTagsBatchItem>;
+};
+export type UpdateTagsBatchItem = {
+    index: number;
+    ok: boolean;
+    name?: string;
+    /**
+     * The name the tag now has, as stored.
+     */
+    newName?: string;
+    /**
+     * How many notes were changed.
+     */
+    notes?: number;
+    error?: ItemError;
+};
+export type DeleteTagsBatchInput = {
+    /**
+     * The tags to delete, 1 to 1000.
+     */
+    names: Array<string>;
+};
+export type UpdateNoteInput = {
+    /**
+     * The fields to change, keyed by each field's key (its name in camelCase, such as `backExtra`) or its exact name. Fields left out keep their content. HTML is allowed.
+     */
+    fields?: {
+        [key: string]: string;
+    };
+    /**
+     * The complete list of tags; it replaces the existing tags.
+     */
+    tags?: Array<string>;
+};
+export type MediaFile = {
+    name: string;
+    size: number;
+    sha1: string;
+    sha256?: string | null;
+    contentType: string;
+    mtime: number;
+    usn: number;
+};
+export type MediaPutResult = MediaFile & {
+    created: boolean;
+    unchanged: boolean;
+};
+export type GeneratedCard = {
+    /**
+     * Numeric id of the card.
+     */
+    id: number;
+    /**
+     * Which template of the note type made this card (0 is the first).
+     */
+    ord: number;
+    /**
+     * The deck the card was put in.
+     */
+    deckId: number;
+    /**
+     * Position in the new-card queue.
+     */
+    due: number;
+};
+export type Card = {
+    id: number;
+    /**
+     * The note this card was made from.
+     */
+    noteId: number;
+    deckId: number;
+    /**
+     * Which template of the note type made this card (0 is the first).
+     */
+    ord: number;
+    mtime?: number;
+    usn?: number;
+    /**
+     * 0 new, 1 learning, 2 review, 3 relearning.
+     */
+    type?: number;
+    /**
+     * Where the card sits in the scheduler: -3 or -2 buried, -1 suspended, 0 new, 1 learning, 2 review, 3 day-learning, 4 preview.
+     */
+    queue?: number;
+    /**
+     * When it is due. For a review card this is a day number; for a new card, its position in the queue.
+     */
+    due?: number;
+    /**
+     * Days until the next review, once it is a review card.
+     */
+    interval?: number;
+    /**
+     * Ease factor in permille: 2500 means 250%.
+     */
+    factor?: number;
+    /**
+     * How many times it has been reviewed.
+     */
+    reps?: number;
+    /**
+     * How many times it was forgotten after being learnt.
+     */
+    lapses?: number;
+    left?: number;
+    originalDue?: number;
+    originalDeckId?: number;
+    /**
+     * Colour flag, 0 for none.
+     */
+    flags?: number;
+};
+export type ItemError = {
+    /**
+     * `not_found`, `invalid_input`, `deck_error`, `card_state_error`, `validation_error`, or `batch_aborted` for an entry that was fine but not written because an atomic call was refused.
+     */
+    code: string;
+    /**
+     * A sentence explaining the refusal.
+     */
+    message: string;
+};
+export type CreateNotesBatchInput = {
+    /**
+     * The notes to create, 1 to 200, each shaped like the body of [Create a note](#createNote). An entry that is not valid is reported in its slot.
+     */
+    notes: Array<CreateNoteInput>;
+    /**
+     * Write all or nothing: one refused entry means nothing is written (`422`).
+     */
+    atomic?: boolean;
+};
+export type CreateNotesBatchResult = {
+    atomic: boolean;
+    committed: boolean;
+    created: number;
+    failed: number;
+    results: Array<CreateNotesBatchItem>;
+};
+export type CreateNotesBatchItem = {
+    /**
+     * Position of the note in `notes`.
+     */
+    index: number;
+    /**
+     * `true` when the note was created.
+     */
+    ok: boolean;
+    /**
+     * Numeric id of the new note.
+     */
+    id?: number;
+    /**
+     * The note's globally unique id.
+     */
+    guid?: string;
+    /**
+     * The cards its note type's templates produced.
+     */
+    cards?: Array<GeneratedCard>;
+    /**
+     * Tags this note introduced; a tag is listed only for the first note that uses it.
+     */
+    newTags?: Array<string>;
+    /**
+     * Why the note was refused. Absent when `ok`.
+     */
+    error?: ItemError;
+};
+export type UpdateNotesBatchInput = {
+    /**
+     * The edits, 1 to 200. An entry that is not valid is reported in its slot.
+     */
+    updates: Array<UpdateNotesBatchEntry>;
+    /**
+     * Write all or nothing: one refused entry means nothing is written (`422`).
+     */
+    atomic?: boolean;
+};
+export type UpdateNotesBatchEntry = {
+    /**
+     * The note to edit.
+     */
+    id: number;
+    /**
+     * The fields to change, keyed like `UpdateNoteInput.fields`. Fields left out keep their content.
+     */
+    fields?: {
+        [key: string]: string;
+    };
+    /**
+     * Replaces all the note's tags. Not with `addTags` or `removeTags`.
+     */
+    tags?: Array<string>;
+    /**
+     * Tags to add to the ones the note has.
+     */
+    addTags?: Array<string>;
+    /**
+     * Tags to remove from the ones the note has, ignoring case. A removed tag takes the tags below it (`a::b` for `a`) with it.
+     */
+    removeTags?: Array<string>;
+};
+export type UpdateNotesBatchResult = {
+    atomic: boolean;
+    committed: boolean;
+    changed: number;
+    failed: number;
+    results: Array<UpdateNotesBatchItem>;
+};
+export type UpdateNotesBatchItem = {
+    /**
+     * Position of the entry in `updates`.
+     */
+    index: number;
+    /**
+     * `true` when the note exists and the edit was valid.
+     */
+    ok: boolean;
+    /**
+     * The note id.
+     */
+    id?: number;
+    /**
+     * `false` when the note already matched, so nothing was written for it.
+     */
+    changed?: boolean;
+    /**
+     * Cards that the new field content caused to be generated.
+     */
+    newCards?: Array<GeneratedCard>;
+    /**
+     * Tags this entry introduced; a tag is listed only for the first entry that uses it.
+     */
+    newTags?: Array<string>;
+    /**
+     * Why the entry was refused. Absent when `ok`.
+     */
+    error?: ItemError;
+};
+export type DeleteCardsBatchInput = {
+    /**
+     * The cards to delete, 1 to 1000.
+     */
+    ids: Array<number>;
+};
+export type UpdateCardsBatchInput = {
+    /**
+     * The cards to change, 1 to 1000. Repeats are ignored.
+     */
+    ids: Array<number>;
+    /**
+     * The change, shaped like the body of [Edit a card](#updateCard).
+     */
+    patch: UpdateCardInput;
+    /**
+     * Write all or nothing: one refused card means nothing is written (`422`).
+     */
+    atomic?: boolean;
+};
+export type UpdateCardsBatchResult = {
+    atomic: boolean;
+    committed: boolean;
+    changed: number;
+    failed: number;
+    results: Array<UpdateCardsBatchItem>;
+};
+export type UpdateCardsBatchItem = {
+    /**
+     * The card id.
+     */
+    id: number;
+    /**
+     * `true` when the card exists and could take the change.
+     */
+    ok: boolean;
+    /**
+     * `false` when the card already matched, so nothing was written for it.
+     */
+    changed?: boolean;
+    /**
+     * The card as stored after the call.
+     */
+    card?: Card | null;
+    /**
+     * Why the card was refused. Absent when `ok`.
+     */
+    error?: ItemError;
+};
+export type DeleteNotesBatchInput = {
+    /**
+     * The notes to delete, 1 to 1000.
+     */
+    ids: Array<number>;
+};
+export type UpdateCardInput = {
+    deckId?: number;
+    flag?: number;
+    suspended?: boolean;
+    buried?: boolean;
+};
+export type AnswerCardInput = {
+    rating: 'again' | 'hard' | 'good' | 'easy' | number;
+    timeTakenMs?: number;
+};
+export type RenderedCard = {
+    cardId: number;
+    noteId?: number;
+    notetypeId?: number;
+    deckId?: number;
+    ord?: number;
+    isEmpty?: boolean;
+    /**
+     * The question or the answer holds a formula (`\(...\)` or `\[...\]`) for MathJax to typeset.
+     */
+    math: boolean;
+    question: string;
+    answer: string;
+    css: string;
+    media: Array<string>;
+};
+export type CardScheduling = {
+    cardId: number;
+    fsrs: boolean;
+    today?: number;
+    nextDayAt?: number;
+    buttons: Array<{
+        rating: 'again' | 'hard' | 'good' | 'easy';
+        intervalSecs: number;
+    }>;
+};
+export type NotetypeChange = {
+    /**
+     * Fields that are new.
+     */
+    fieldsAdded: number;
+    /**
+     * Fields that were removed, with their content.
+     */
+    fieldsRemoved: number;
+    /**
+     * Fields that kept their data but changed position.
+     */
+    fieldsMoved: number;
+    /**
+     * `true` when a different field is now the one the browser sorts by.
+     */
+    sortFieldChanged: boolean;
+    /**
+     * Card templates that are new.
+     */
+    templatesAdded: number;
+    /**
+     * Card templates that were removed.
+     */
+    templatesRemoved: number;
+    /**
+     * Card templates that changed position.
+     */
+    templatesMoved: number;
+    /**
+     * `true` when any field or template was removed, so note or card data was lost.
+     */
+    destructive: boolean;
+};
+export type NoteTypeDetails = {
+    id: number;
+    name: string;
+    /**
+     * `normal` makes one card per template; `cloze` makes one per cloze deletion.
+     */
+    kind: 'normal' | 'cloze';
+    /**
+     * Stylesheet shared by every card of this note type.
+     */
+    css?: string;
+    /**
+     * Index of the field the browser sorts by.
+     */
+    sortFieldIdx?: number;
+    latexPre?: string;
+    latexPost?: string;
+    latexSvg?: boolean;
+    fields: Array<NoteTypeField>;
+    templates: Array<{
+        [key: string]: unknown;
+    }>;
+};
+export type NoteTypeField = {
+    ord: number;
+    /**
+     * The field's name as Anki shows it.
+     */
+    name: string;
+    /**
+     * The key of this field in the `fields` of a note, whether you create, read or edit it: its name in camelCase (`The field` is `theField`). When two fields would get the same key, or a field's exact name is another field's key, they keep their exact names.
+     */
+    key: string;
+    sticky?: boolean;
+    rtl?: boolean;
+    plainText?: boolean;
+    collapsed?: boolean;
+    excludeFromSearch?: boolean;
+    preventDeletion?: boolean;
+    description?: string;
+    fontName?: string;
+    fontSize?: number;
+};
+export type CreateNotetypeInput = {
+    /**
+     * Start from one of Anki's stock designs.
+     */
+    stock?: string;
+    /**
+     * Name of the note type.
+     */
+    name?: string;
+    kind?: 'normal' | 'cloze';
+    /**
+     * Field definitions, in order. Each needs a `name`.
+     */
+    fields?: Array<{
+        [key: string]: unknown;
+    }>;
+    /**
+     * Card templates. Each needs a `name`, a question format `qFormat` and an answer format `aFormat`.
+     */
+    templates?: Array<{
+        [key: string]: unknown;
+    }>;
+    css?: string;
+    sortFieldIdx?: number;
+};
+export type UpdateNotetypeInput = {
+    name?: string;
+    css?: string;
+    sortFieldIdx?: number;
+    /**
+     * The full list of fields. A field with an `ord` is an existing one being kept or renamed; one without is new; an existing one that is missing is removed.
+     */
+    fields?: Array<{
+        [key: string]: unknown;
+    }>;
+    /**
+     * The full list of templates, following the same rule as `fields`.
+     */
+    templates?: Array<{
+        [key: string]: unknown;
+    }>;
+};
+export type ApiError = {
+    error: {
+        code: string;
+        message: string;
+        correlationId?: string;
+    };
+    correlationId?: string;
+};
+export type ListDecksData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/decks';
+};
+export type ListDecksErrors = {
+    /**
+     * The `Authorization` header is missing, or the key is invalid, disabled or expired.
+     */
+    401: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type ListDecksError = ListDecksErrors[keyof ListDecksErrors];
+export type ListDecksResponses = {
+    /**
+     * List of decks
+     */
+    200: {
+        /**
+         * Every deck, in no particular order.
+         */
+        decks: Array<Deck>;
+    };
+};
+export type ListDecksResponse = ListDecksResponses[keyof ListDecksResponses];
+export type CreateDeckData = {
+    body: {
+        /**
+         * Deck name. Use `::` to nest it.
+         */
+        name: string;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/decks';
+};
+export type CreateDeckErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The `Authorization` header is missing, or the key is invalid, disabled or expired.
+     */
+    401: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The body does not match the earlier request that used this `Idempotency-Key` (`idempotency_conflict`), or the body failed validation (`validation_error`).
+     */
+    422: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type CreateDeckError = CreateDeckErrors[keyof CreateDeckErrors];
+export type CreateDeckResponses = {
+    /**
+     * Deck created
+     */
+    201: Deck;
+};
+export type CreateDeckResponse = CreateDeckResponses[keyof CreateDeckResponses];
+export type DeleteDeckData = {
+    body?: never;
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/decks/{id}';
+};
+export type DeleteDeckErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type DeleteDeckError = DeleteDeckErrors[keyof DeleteDeckErrors];
+export type DeleteDeckResponses = {
+    /**
+     * Deck deleted
+     */
+    200: {
+        /**
+         * `true` when the deck was deleted.
+         */
+        ok: boolean;
+        /**
+         * The deck and each of its subdecks.
+         */
+        deletedDeckIds: Array<number>;
+        /**
+         * Every card that was in those decks.
+         */
+        deletedCardIds: Array<number>;
+        /**
+         * Notes that were left with no cards and were removed with them.
+         */
+        deletedNoteIds: Array<number>;
+        /**
+         * `true` when the built-in `Default` deck was among the decks. It cannot be removed, so it was emptied and kept.
+         */
+        defaultDeckReset: boolean;
+        /**
+         * Cards that were in a deleted filtered deck. They go back to the deck they came from instead of being deleted.
+         */
+        returnedCardIds: Array<number>;
+    };
+};
+export type DeleteDeckResponse = DeleteDeckResponses[keyof DeleteDeckResponses];
+export type GetDeckData = {
+    body?: never;
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/decks/{id}';
+};
+export type GetDeckErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type GetDeckError = GetDeckErrors[keyof GetDeckErrors];
+export type GetDeckResponses = {
+    /**
+     * Deck details
+     */
+    200: Deck;
+};
+export type GetDeckResponse = GetDeckResponses[keyof GetDeckResponses];
+export type RenameDeckData = {
+    body: {
+        /**
+         * The new full name.
+         */
+        name: string;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/decks/{id}';
+};
+export type RenameDeckErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type RenameDeckError = RenameDeckErrors[keyof RenameDeckErrors];
+export type RenameDeckResponses = {
+    /**
+     * Deck renamed
+     */
+    200: Deck;
+};
+export type RenameDeckResponse = RenameDeckResponses[keyof RenameDeckResponses];
+export type ListNotesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Only items that belong to this deck.
+         */
+        deckId?: number;
+        /**
+         * Only notes of this note type.
+         */
+        notetypeId?: number;
+        /**
+         * Only notes that carry exactly this tag.
+         */
+        tag?: string;
+        /**
+         * The id of the last item on the previous page, which is its `nextCursor`. Leave it out for the first page.
+         */
+        cursor?: string;
+        /**
+         * Page size, from 1 to 100. Defaults to 50.
+         */
+        limit?: number;
+    };
+    url: '/api/v1/notes';
+};
+export type ListNotesErrors = {
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type ListNotesError = ListNotesErrors[keyof ListNotesErrors];
+export type ListNotesResponses = {
+    /**
+     * Paginated list of notes
+     */
+    200: {
+        /**
+         * This page of notes, in ascending id order.
+         */
+        notes: Array<Note>;
+        /**
+         * Send this as `cursor` to get the next page. `null` on the last page.
+         */
+        nextCursor: string | null;
+    };
+};
+export type ListNotesResponse = ListNotesResponses[keyof ListNotesResponses];
+export type CreateNoteData = {
+    body: {
+        /**
+         * Which note type to use, by name (ignoring case). Send this or `notetypeId`.
+         */
+        notetypeName?: string;
+        /**
+         * Which note type to use, by id. See [List note types](#listNoteTypes). Send this or `notetypeName`.
+         */
+        notetypeId?: number;
+        /**
+         * The deck that receives the new cards, by name (ignoring case), such as `Languages::German`. Send this or `deckId`.
+         */
+        deckName?: string;
+        /**
+         * The deck that receives the new cards, by id. Without a deck the note goes to the `Default` deck.
+         */
+        deckId?: number;
+        /**
+         * The field contents, keyed by each field's key: its name in camelCase (`Back Extra` is `backExtra`) or its exact name. Fields left out are empty. HTML is allowed.
+         */
+        fields: {
+            [key: string]: string;
+        };
+        /**
+         * Tags to put on the note.
+         */
+        tags?: Array<string>;
+        /**
+         * Optional. Only set it to keep an identity from another system.
+         */
+        guid?: string;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/notes';
+};
+export type CreateNoteErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The body does not match the earlier request that used this `Idempotency-Key` (`idempotency_conflict`), or the body failed validation (`validation_error`).
+     */
+    422: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type CreateNoteError = CreateNoteErrors[keyof CreateNoteErrors];
+export type CreateNoteResponses = {
+    /**
+     * Note created
+     */
+    201: {
+        /**
+         * Numeric id of the new note.
+         */
+        id: number;
+        /**
+         * The note's globally unique id: the one you sent, or a generated one.
+         */
+        guid: string;
+        /**
+         * The cards the note type's templates produced.
+         */
+        cards: Array<GeneratedCard>;
+        /**
+         * Tags that did not exist in the collection before and were created by this request.
+         */
+        newTags: Array<string>;
+    };
+};
+export type CreateNoteResponse = CreateNoteResponses[keyof CreateNoteResponses];
+export type CreateNotesBatchData = {
+    body: {
+        /**
+         * The notes to create, 1 to 200, each shaped like the body of [Create a note](#createNote). An entry that is not valid is reported in its slot.
+         */
+        notes: Array<CreateNoteInput>;
+        /**
+         * Write all or nothing: one refused entry means nothing is written (`422`).
+         */
+        atomic?: boolean;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/notes/batch-create';
+};
+export type CreateNotesBatchErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The body failed validation (`validation_error`), or the call was `atomic` and an entry was refused: then the body is the usual batch answer with every entry's `error`, and nothing was written.
+     */
+    422: ApiError | CreateNotesBatchResult | UpdateNotesBatchResult | UpdateCardsBatchResult;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+    /**
+     * Other batch operations are using the server. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    503: ApiError;
+};
+export type CreateNotesBatchError = CreateNotesBatchErrors[keyof CreateNotesBatchErrors];
+export type CreateNotesBatchResponses = {
+    /**
+     * Every entry was handled; see `results`
+     */
+    200: CreateNotesBatchResult;
+};
+export type CreateNotesBatchResponse = CreateNotesBatchResponses[keyof CreateNotesBatchResponses];
+export type UpdateNotesBatchData = {
+    body: {
+        /**
+         * The edits, 1 to 200. An entry that is not valid is reported in its slot.
+         */
+        updates: Array<UpdateNotesBatchEntry>;
+        /**
+         * Write all or nothing: one refused entry means nothing is written (`422`).
+         */
+        atomic?: boolean;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/notes/batch-update';
+};
+export type UpdateNotesBatchErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The body failed validation (`validation_error`), or the call was `atomic` and an entry was refused: then the body is the usual batch answer with every entry's `error`, and nothing was written.
+     */
+    422: ApiError | CreateNotesBatchResult | UpdateNotesBatchResult | UpdateCardsBatchResult;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+    /**
+     * Other batch operations are using the server. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    503: ApiError;
+};
+export type UpdateNotesBatchError = UpdateNotesBatchErrors[keyof UpdateNotesBatchErrors];
+export type UpdateNotesBatchResponses = {
+    /**
+     * Every entry was handled; see `results`
+     */
+    200: UpdateNotesBatchResult;
+};
+export type UpdateNotesBatchResponse = UpdateNotesBatchResponses[keyof UpdateNotesBatchResponses];
+export type DeleteNotesBatchData = {
+    body: {
+        /**
+         * The notes to delete, 1 to 1000.
+         */
+        ids: Array<number>;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/notes/batch-delete';
+};
+export type DeleteNotesBatchErrors = {
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The body does not match the earlier request that used this `Idempotency-Key` (`idempotency_conflict`), or the body failed validation (`validation_error`).
+     */
+    422: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+    /**
+     * Other batch operations are using the server. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    503: ApiError;
+};
+export type DeleteNotesBatchError = DeleteNotesBatchErrors[keyof DeleteNotesBatchErrors];
+export type DeleteNotesBatchResponses = {
+    /**
+     * The notes that existed were deleted
+     */
+    200: {
+        /**
+         * How many notes were deleted.
+         */
+        deleted: number;
+        /**
+         * The notes that were deleted.
+         */
+        deletedNoteIds: Array<number>;
+        /**
+         * Every card that was made from them.
+         */
+        deletedCardIds: Array<number>;
+        /**
+         * Ids that did not exist and were ignored.
+         */
+        missingNoteIds: Array<number>;
+    };
+};
+export type DeleteNotesBatchResponse = DeleteNotesBatchResponses[keyof DeleteNotesBatchResponses];
+export type DeleteNoteData = {
+    body?: never;
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/notes/{id}';
+};
+export type DeleteNoteErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type DeleteNoteError = DeleteNoteErrors[keyof DeleteNoteErrors];
+export type DeleteNoteResponses = {
+    /**
+     * Note deleted
+     */
+    200: {
+        /**
+         * `true` when the note was deleted.
+         */
+        ok: boolean;
+        /**
+         * The note that was deleted.
+         */
+        deletedNoteIds: Array<number>;
+        /**
+         * Every card that was made from it.
+         */
+        deletedCardIds: Array<number>;
+    };
+};
+export type DeleteNoteResponse = DeleteNoteResponses[keyof DeleteNoteResponses];
+export type GetNoteData = {
+    body?: never;
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/notes/{id}';
+};
+export type GetNoteErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type GetNoteError = GetNoteErrors[keyof GetNoteErrors];
+export type GetNoteResponses = {
+    /**
+     * Note details
+     */
+    200: NoteDetails;
+};
+export type GetNoteResponse = GetNoteResponses[keyof GetNoteResponses];
+export type UpdateNoteData = {
+    body: {
+        /**
+         * The fields to change, keyed by each field's key (its name in camelCase, such as `backExtra`) or its exact name. Fields left out keep their content. HTML is allowed.
+         */
+        fields?: {
+            [key: string]: string;
+        };
+        /**
+         * The complete list of tags; it replaces the existing tags.
+         */
+        tags?: Array<string>;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/notes/{id}';
+};
+export type UpdateNoteErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type UpdateNoteError = UpdateNoteErrors[keyof UpdateNoteErrors];
+export type UpdateNoteResponses = {
+    /**
+     * Note updated
+     */
+    200: {
+        /**
+         * Numeric id of the note.
+         */
+        id: number;
+        /**
+         * `false` when nothing differed from what was stored, so nothing was written.
+         */
+        changed: boolean;
+        /**
+         * Cards that the new field content caused to be generated.
+         */
+        newCards: Array<GeneratedCard>;
+        /**
+         * Tags that did not exist in the collection before and were created by this request.
+         */
+        newTags: Array<string>;
+    };
+};
+export type UpdateNoteResponse = UpdateNoteResponses[keyof UpdateNoteResponses];
+export type ListNoteTypesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/note-types';
+};
+export type ListNoteTypesErrors = {
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type ListNoteTypesError = ListNoteTypesErrors[keyof ListNoteTypesErrors];
+export type ListNoteTypesResponses = {
+    /**
+     * List of note types
+     */
+    200: {
+        /**
+         * Every note type, with its id and name. Fetch one by id for its fields and templates.
+         */
+        noteTypes: Array<{
+            id?: number;
+            name?: string;
+        }>;
+    };
+};
+export type ListNoteTypesResponse = ListNoteTypesResponses[keyof ListNoteTypesResponses];
+export type CreateNoteTypeData = {
+    body: {
+        /**
+         * Start from one of Anki's stock designs.
+         */
+        stock?: string;
+        /**
+         * Name of the note type.
+         */
+        name?: string;
+        kind?: 'normal' | 'cloze';
+        /**
+         * Field definitions, in order. Each needs a `name`.
+         */
+        fields?: Array<{
+            [key: string]: unknown;
+        }>;
+        /**
+         * Card templates. Each needs a `name`, a question format `qFormat` and an answer format `aFormat`.
+         */
+        templates?: Array<{
+            [key: string]: unknown;
+        }>;
+        css?: string;
+        sortFieldIdx?: number;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/note-types';
+};
+export type CreateNoteTypeErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type CreateNoteTypeError = CreateNoteTypeErrors[keyof CreateNoteTypeErrors];
+export type CreateNoteTypeResponses = {
+    /**
+     * Note type created
+     */
+    201: {
+        /**
+         * Numeric id of the new note type.
+         */
+        id: number;
+        /**
+         * Its name.
+         */
+        name: string;
+    };
+};
+export type CreateNoteTypeResponse = CreateNoteTypeResponses[keyof CreateNoteTypeResponses];
+export type DeleteNoteTypeData = {
+    body?: never;
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * Set to `true` to accept that this change forces every device to download the whole collection again on its next sync. Without it the request is refused with `409 full_sync_required`.
+         */
+        acceptFullSync?: boolean;
+    };
+    url: '/api/v1/note-types/{id}';
+};
+export type DeleteNoteTypeErrors = {
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The change alters the collection's schema and needs `?acceptFullSync=true` (`full_sync_required`), or the card is in a state that does not allow this (`card_state_error`: suspended, buried, in a filtered deck, or an unsupported scheduler).
+     */
+    409: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type DeleteNoteTypeError = DeleteNoteTypeErrors[keyof DeleteNoteTypeErrors];
+export type DeleteNoteTypeResponses = {
+    /**
+     * Note type deleted
+     */
+    200: {
+        /**
+         * `true` when the note type was deleted.
+         */
+        ok: boolean;
+        /**
+         * Notes that used the note type and were removed.
+         */
+        deletedNotes: number;
+        /**
+         * Cards of those notes, removed with them.
+         */
+        deletedCards: number;
+        /**
+         * The note type Anki now treats as current: the first by name, or a new Basic one if none were left.
+         */
+        currentNotetypeId: number;
+        /**
+         * `true` when that was the last note type, so a stock Basic one was added.
+         */
+        addedBasic: boolean;
+    };
+};
+export type DeleteNoteTypeResponse = DeleteNoteTypeResponses[keyof DeleteNoteTypeResponses];
+export type GetNoteTypeData = {
+    body?: never;
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/note-types/{id}';
+};
+export type GetNoteTypeErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type GetNoteTypeError = GetNoteTypeErrors[keyof GetNoteTypeErrors];
+export type GetNoteTypeResponses = {
+    /**
+     * Note type details
+     */
+    200: NoteTypeDetails;
+};
+export type GetNoteTypeResponse = GetNoteTypeResponses[keyof GetNoteTypeResponses];
+export type UpdateNoteTypeData = {
+    body: {
+        name?: string;
+        css?: string;
+        sortFieldIdx?: number;
+        /**
+         * The full list of fields. A field with an `ord` is an existing one being kept or renamed; one without is new; an existing one that is missing is removed.
+         */
+        fields?: Array<{
+            [key: string]: unknown;
+        }>;
+        /**
+         * The full list of templates, following the same rule as `fields`.
+         */
+        templates?: Array<{
+            [key: string]: unknown;
+        }>;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * Set to `true` to accept that this change forces every device to download the whole collection again on its next sync. Without it the request is refused with `409 full_sync_required`.
+         */
+        acceptFullSync?: boolean;
+    };
+    url: '/api/v1/note-types/{id}';
+};
+export type UpdateNoteTypeErrors = {
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The change alters the collection's schema and needs `?acceptFullSync=true` (`full_sync_required`), or the card is in a state that does not allow this (`card_state_error`: suspended, buried, in a filtered deck, or an unsupported scheduler).
+     */
+    409: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type UpdateNoteTypeError = UpdateNoteTypeErrors[keyof UpdateNoteTypeErrors];
+export type UpdateNoteTypeResponses = {
+    /**
+     * Note type updated
+     */
+    200: {
+        /**
+         * Numeric id of the note type.
+         */
+        id: number;
+        /**
+         * Its name after the change.
+         */
+        name: string;
+        /**
+         * `true` when the change altered the collection's schema, so every device downloads the whole collection on its next sync.
+         */
+        schemaChanged: boolean;
+        /**
+         * What the change did to the note type's structure: how many fields and templates were added, removed or moved.
+         */
+        change: NotetypeChange;
+        /**
+         * Notes that were rewritten because a field was added, removed or moved, or the sort field changed.
+         */
+        updatedNotes: number;
+        /**
+         * Cards that were deleted because their template was removed.
+         */
+        deletedCards: number;
+        /**
+         * Cards whose template moved to a different position, so their number changed.
+         */
+        movedCards: number;
+        /**
+         * Cards that were generated because a template was added or now produces a card.
+         */
+        newCards: number;
+    };
+};
+export type UpdateNoteTypeResponse = UpdateNoteTypeResponses[keyof UpdateNoteTypeResponses];
+export type GetStudyQueueData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Only items that belong to this deck.
+         */
+        deckId?: number;
+        /**
+         * Page size, from 1 to 100. Defaults to 50.
+         */
+        limit?: number;
+    };
+    url: '/api/v1/queue';
+};
+export type GetStudyQueueErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The change alters the collection's schema and needs `?acceptFullSync=true` (`full_sync_required`), or the card is in a state that does not allow this (`card_state_error`: suspended, buried, in a filtered deck, or an unsupported scheduler).
+     */
+    409: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type GetStudyQueueError = GetStudyQueueErrors[keyof GetStudyQueueErrors];
+export type GetStudyQueueResponses = {
+    /**
+     * The next cards to study, in order
+     */
+    200: {
+        deckId: number;
+        counts: {
+            new: number;
+            learning: number;
+            review: number;
+        };
+        total: number;
+        learnAheadSecs: number;
+        cards: Array<Card & {
+            kind: 'new' | 'learning' | 'review';
+        }>;
+    };
+};
+export type GetStudyQueueResponse = GetStudyQueueResponses[keyof GetStudyQueueResponses];
+export type ListTagsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/tags';
+};
+export type ListTagsErrors = {
+    /**
+     * The `Authorization` header is missing, or the key is invalid, disabled or expired.
+     */
+    401: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type ListTagsError = ListTagsErrors[keyof ListTagsErrors];
+export type ListTagsResponses = {
+    /**
+     * List of tags
+     */
+    200: {
+        /**
+         * Every tag, sorted by name.
+         */
+        tags: Array<string>;
+    };
+};
+export type ListTagsResponse = ListTagsResponses[keyof ListTagsResponses];
+export type CreateTagData = {
+    body: {
+        /**
+         * The tag, with `::` for nesting. It can not contain a space or have an empty part.
+         */
+        name: string;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/tags';
+};
+export type CreateTagErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The body does not match the earlier request that used this `Idempotency-Key` (`idempotency_conflict`), or the body failed validation (`validation_error`).
+     */
+    422: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type CreateTagError = CreateTagErrors[keyof CreateTagErrors];
+export type CreateTagResponses = {
+    /**
+     * The tag already existed
+     */
+    200: CreatedTag;
+    /**
+     * Tag created
+     */
+    201: CreatedTag;
+};
+export type CreateTagResponse = CreateTagResponses[keyof CreateTagResponses];
+export type DeleteTagData = {
+    body?: never;
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The tag's name, percent-encoded: `Languages%3A%3AGerman` is `Languages::German`.
+         */
+        name: string;
+    };
+    query?: never;
+    url: '/api/v1/tags/{name}';
+};
+export type DeleteTagErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type DeleteTagError = DeleteTagErrors[keyof DeleteTagErrors];
+export type DeleteTagResponses = {
+    /**
+     * Tag deleted
+     */
+    200: {
+        ok: boolean;
+        /**
+         * The tags that were removed from the list: the one named and those nested under it.
+         */
+        deletedTags: Array<string>;
+        /**
+         * How many notes lost a tag.
+         */
+        notes: number;
+    };
+};
+export type DeleteTagResponse = DeleteTagResponses[keyof DeleteTagResponses];
+export type GetTagData = {
+    body?: never;
+    path: {
+        /**
+         * The tag's name, percent-encoded: `Languages%3A%3AGerman` is `Languages::German`.
+         */
+        name: string;
+    };
+    query?: never;
+    url: '/api/v1/tags/{name}';
+};
+export type GetTagErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type GetTagError = GetTagErrors[keyof GetTagErrors];
+export type GetTagResponses = {
+    /**
+     * Tag details
+     */
+    200: Tag;
+};
+export type GetTagResponse = GetTagResponses[keyof GetTagResponses];
+export type RenameTagData = {
+    body: {
+        /**
+         * The new name. If it is already a tag, the two are merged.
+         */
+        newName: string;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The tag's name, percent-encoded: `Languages%3A%3AGerman` is `Languages::German`.
+         */
+        name: string;
+    };
+    query?: never;
+    url: '/api/v1/tags/{name}';
+};
+export type RenameTagErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The body does not match the earlier request that used this `Idempotency-Key` (`idempotency_conflict`), or the body failed validation (`validation_error`).
+     */
+    422: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type RenameTagError = RenameTagErrors[keyof RenameTagErrors];
+export type RenameTagResponses = {
+    /**
+     * Tag renamed
+     */
+    200: RenamedTag;
+};
+export type RenameTagResponse = RenameTagResponses[keyof RenameTagResponses];
+export type CreateTagsBatchData = {
+    body: {
+        /**
+         * The tags to create, 1 to 200.
+         */
+        names: Array<string>;
+        /**
+         * Write all or nothing. See [Create many notes](#createNotesBatch).
+         */
+        atomic?: boolean;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/tags/batch-create';
+};
+export type CreateTagsBatchErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The body failed validation (`validation_error`), or the call was `atomic` and an entry was refused: then the body is the usual batch answer with every entry's `error`, and nothing was written.
+     */
+    422: ApiError | CreateNotesBatchResult | UpdateNotesBatchResult | UpdateCardsBatchResult;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+    /**
+     * Other batch operations are using the server. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    503: ApiError;
+};
+export type CreateTagsBatchError = CreateTagsBatchErrors[keyof CreateTagsBatchErrors];
+export type CreateTagsBatchResponses = {
+    /**
+     * Every entry was handled; see `results`
+     */
+    200: CreateTagsBatchResult;
+};
+export type CreateTagsBatchResponse = CreateTagsBatchResponses[keyof CreateTagsBatchResponses];
+export type UpdateTagsBatchData = {
+    body: {
+        /**
+         * The renames, 1 to 200.
+         */
+        updates: Array<UpdateTagsBatchEntry>;
+        /**
+         * Write all or nothing. See [Create many notes](#createNotesBatch).
+         */
+        atomic?: boolean;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/tags/batch-update';
+};
+export type UpdateTagsBatchErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The body failed validation (`validation_error`), or the call was `atomic` and an entry was refused: then the body is the usual batch answer with every entry's `error`, and nothing was written.
+     */
+    422: ApiError | CreateNotesBatchResult | UpdateNotesBatchResult | UpdateCardsBatchResult;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+    /**
+     * Other batch operations are using the server. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    503: ApiError;
+};
+export type UpdateTagsBatchError = UpdateTagsBatchErrors[keyof UpdateTagsBatchErrors];
+export type UpdateTagsBatchResponses = {
+    /**
+     * Every entry was handled; see `results`
+     */
+    200: UpdateTagsBatchResult;
+};
+export type UpdateTagsBatchResponse = UpdateTagsBatchResponses[keyof UpdateTagsBatchResponses];
+export type DeleteTagsBatchData = {
+    body: {
+        /**
+         * The tags to delete, 1 to 1000.
+         */
+        names: Array<string>;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/tags/batch-delete';
+};
+export type DeleteTagsBatchErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+    /**
+     * Other batch operations are using the server. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    503: ApiError;
+};
+export type DeleteTagsBatchError = DeleteTagsBatchErrors[keyof DeleteTagsBatchErrors];
+export type DeleteTagsBatchResponses = {
+    /**
+     * The tags that existed were deleted
+     */
+    200: {
+        /**
+         * How many tags were removed from the list.
+         */
+        deleted: number;
+        /**
+         * The tags that were removed: those named and those nested under them.
+         */
+        deletedTags: Array<string>;
+        /**
+         * How many notes lost a tag.
+         */
+        notes: number;
+        /**
+         * Names that matched nothing and were ignored.
+         */
+        missingNames: Array<string>;
+    };
+};
+export type DeleteTagsBatchResponse = DeleteTagsBatchResponses[keyof DeleteTagsBatchResponses];
+export type GetStatsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * A search, written in Anki's search syntax (the Searching chapter of the Anki manual): the same text you would type in the browser. Words match note text; `-` negates; `or`, `and` and parentheses combine; quotes group. Fields: `front:dog`, `front:*og`, `front:re:^d`, `*:text`, `nc:cafe` (ignore accents), `sc:text` (inside clozes), `re:regex`, `w:word`, `dupe:notetypeId,text`. Notes and cards: `deck:`, `note:`, `card:`, `tag:`, `preset:`, `flag:`, `nid:`, `cid:`, `is:new|learn|review|due|suspended|buried|buried-manually|buried-sibling`. Time: `added:`, `edited:`, `introduced:`, `rated:days[:button]`, `resched:`. Properties: `prop:ivl>=21`, `reps`, `lapses`, `ease`, `due`, `pos`, `rated`, and FSRS `s`, `d`, `r`; `prop:cdn:key>1`, `prop:cds:key=x` and `has-cd:key` for custom data. A search that Anki would refuse is `400 invalid_input` with Anki's own explanation. Differences from desktop Anki: regular expressions run on the RE2 engine (a `(?x)` flag, class set operations such as `[a-z&&[^aeiou]]`, backreferences and `\Q..\E` are `400 invalid_input`, and `\b` uses ASCII word characters, so use `w:` for Unicode words), and a search may be at most 1000 characters and 50 terms.
+         */
+        q?: string;
+        /**
+         * Days of review history to count, from today back; `0` (the default) is all of it. At most 36500.
+         */
+        days?: number;
+    };
+    url: '/api/v1/stats';
+};
+export type GetStatsErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type GetStatsError = GetStatsErrors[keyof GetStatsErrors];
+export type GetStatsResponses = {
+    /**
+     * The graphs of Anki's statistics screen
+     */
+    200: {
+        /**
+         * How many times each answer button (Again, Hard, Good, Easy: the four numbers, in that order) was pressed, in learning, on young review cards (interval under 21 days) and on mature ones, over the last month, three months, year and all time.
+         */
+        buttons: {
+            oneMonth: {
+                learning: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+                young: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+                mature: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+            };
+            threeMonths: {
+                learning: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+                young: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+                mature: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+            };
+            oneYear: {
+                learning: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+                young: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+                mature: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+            };
+            allTime: {
+                learning: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+                young: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+                mature: [
+                    number,
+                    number,
+                    number,
+                    number
+                ];
+            };
+        };
+        /**
+         * Cards by kind. `includingInactive` counts suspended and buried cards by their kind; `excludingInactive` counts them only as `suspended` and `buried`. `young` and `mature` are review cards with an interval under and over 21 days.
+         */
+        cardCounts: {
+            includingInactive: {
+                new: number;
+                learn: number;
+                relearn: number;
+                young: number;
+                mature: number;
+                suspended: number;
+                buried: number;
+            };
+            excludingInactive: {
+                new: number;
+                learn: number;
+                relearn: number;
+                young: number;
+                mature: number;
+                suspended: number;
+                buried: number;
+            };
+        };
+        /**
+         * Answers by hour of the day (24 entries, hour 0 first), in the collection's `localOffset`: how many (`total`) and how many were not Again (`correct`), over the last month, three months, year and all time.
+         */
+        hours: {
+            oneMonth: [
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                }
+            ];
+            threeMonths: [
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                }
+            ];
+            oneYear: [
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                }
+            ];
+            allTime: [
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                },
+                {
+                    total: number;
+                    correct: number;
+                }
+            ];
+        };
+        /**
+         * What was answered since the last day rollover: the number of answers and the milliseconds they took, how many were not Again, how many of those were on mature cards, and the answers by kind (`earlyReviewCount` is answers in a filtered deck).
+         */
+        today: {
+            answerCount: number;
+            answerMillis: number;
+            correctCount: number;
+            matureCorrect: number;
+            matureCount: number;
+            learnCount: number;
+            reviewCount: number;
+            relearnCount: number;
+            earlyReviewCount: number;
+        };
+        /**
+         * SM-2 cards: how many have each ease, as a percent (250 is 250%), and the median ease. Cards with an FSRS memory state are in `difficulty`.
+         */
+        eases: {
+            eases: {
+                [key: string]: number;
+            };
+            average: number;
+        };
+        /**
+         * FSRS cards: how many fall in each 1% bin of difficulty (0 to 99), and the median difficulty in percent.
+         */
+        difficulty: {
+            eases: {
+                [key: string]: number;
+            };
+            average: number;
+        };
+        /**
+         * Review and relearning cards by interval, in days.
+         */
+        intervals: {
+            intervals: {
+                [key: string]: number;
+            };
+        };
+        /**
+         * FSRS cards by stability, in days, rounded.
+         */
+        stability: {
+            intervals: {
+                [key: string]: number;
+            };
+        };
+        /**
+         * Cards that are due, by day (0 is today, 1 tomorrow, negative is overdue): suspended and new cards are left out, and buried cards that are already due. `haveBacklog` is true when something is overdue. `dailyLoad` is the average number of reviews a day the collection needs, from the intervals.
+         */
+        futureDue: {
+            futureDue: {
+                [key: string]: number;
+            };
+            haveBacklog: boolean;
+            dailyLoad: number;
+        };
+        /**
+         * Cards by the day they were created (0 is today, -1 yesterday).
+         */
+        added: {
+            added: {
+                [key: string]: number;
+            };
+        };
+        /**
+         * Answers (`count`) and the milliseconds they took (`time`) by day (0 is today, -1 yesterday), split into learning, relearning, young and mature review cards and filtered decks. Manual changes to the schedule are not answers.
+         */
+        reviews: {
+            count: {
+                [key: string]: {
+                    learn: number;
+                    relearn: number;
+                    young: number;
+                    mature: number;
+                    filtered: number;
+                };
+            };
+            time: {
+                [key: string]: {
+                    learn: number;
+                    relearn: number;
+                    young: number;
+                    mature: number;
+                    filtered: number;
+                };
+            };
+        };
+        /**
+         * The hour of the day a new day starts (the `rollover` setting).
+         */
+        rolloverHour: number;
+        /**
+         * FSRS cards: how many fall in each 1% bin of the chance of recalling them now, the average in percent, and the sum of the chances over cards and over notes (the expected number of cards, and of notes, remembered).
+         */
+        retrievability: {
+            retrievability: {
+                [key: string]: number;
+            };
+            average: number;
+            sumByCard: number;
+            sumByNote: number;
+        };
+        /**
+         * Whether the collection has FSRS turned on.
+         */
+        fsrs: boolean;
+        /**
+         * Of the review answers on cards that had an interval of a day or more, how many were passed and how many failed (Again), for young and mature cards: today, yesterday, the last week, month and year, and all time.
+         */
+        trueRetention: {
+            today: {
+                youngPassed: number;
+                youngFailed: number;
+                maturePassed: number;
+                matureFailed: number;
+            };
+            yesterday: {
+                youngPassed: number;
+                youngFailed: number;
+                maturePassed: number;
+                matureFailed: number;
+            };
+            week: {
+                youngPassed: number;
+                youngFailed: number;
+                maturePassed: number;
+                matureFailed: number;
+            };
+            month: {
+                youngPassed: number;
+                youngFailed: number;
+                maturePassed: number;
+                matureFailed: number;
+            };
+            year: {
+                youngPassed: number;
+                youngFailed: number;
+                maturePassed: number;
+                matureFailed: number;
+            };
+            allTime: {
+                youngPassed: number;
+                youngFailed: number;
+                maturePassed: number;
+                matureFailed: number;
+            };
+        };
+        /**
+         * The number of cards the search matched.
+         */
+        cards: number;
+        /**
+         * The number of review-log entries read, which is the history inside `days` of the matched cards (all entries for an empty search, even those of deleted cards).
+         */
+        reviewEntries: number;
+        /**
+         * The clock the graphs use: `now` (when they were computed, which for a repeated request can be a few minutes ago) and `nextDayAt` (when the current day ends) in seconds since the epoch, `daysElapsed` since the collection was created, and `localOffsetSecs` east of UTC.
+         */
+        timing: {
+            now: number;
+            daysElapsed: number;
+            nextDayAt: number;
+            localOffsetSecs: number;
+        };
+    };
+};
+export type GetStatsResponse = GetStatsResponses[keyof GetStatsResponses];
+export type ListMediaData = {
+    body?: never;
+    path?: never;
+    query?: {
+        prefix?: string;
+        /**
+         * Page size, from 1 to 100. Defaults to 50.
+         */
+        limit?: number;
+        /**
+         * The id of the last item on the previous page, which is its `nextCursor`. Leave it out for the first page.
+         */
+        cursor?: string;
+    };
+    url: '/api/v1/media';
+};
+export type ListMediaErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type ListMediaError = ListMediaErrors[keyof ListMediaErrors];
+export type ListMediaResponses = {
+    /**
+     * A page of media files, in name order
+     */
+    200: {
+        items: Array<MediaFile>;
+        nextCursor: string | null;
+    };
+};
+export type ListMediaResponse = ListMediaResponses[keyof ListMediaResponses];
+export type DeleteMediaData = {
+    body?: never;
+    path: {
+        /**
+         * The tag's name, percent-encoded: `Languages%3A%3AGerman` is `Languages::German`.
+         */
+        name: string;
+    };
+    query?: never;
+    url: '/api/v1/media/{name}';
+};
+export type DeleteMediaErrors = {
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type DeleteMediaError = DeleteMediaErrors[keyof DeleteMediaErrors];
+export type DeleteMediaResponses = {
+    /**
+     * The file was deleted
+     */
+    200: {
+        ok: boolean;
+        name: string;
+        usn: number;
+    };
+};
+export type DeleteMediaResponse = DeleteMediaResponses[keyof DeleteMediaResponses];
+export type GetMediaData = {
+    body?: never;
+    headers?: {
+        Range?: string;
+    };
+    path: {
+        /**
+         * The tag's name, percent-encoded: `Languages%3A%3AGerman` is `Languages::German`.
+         */
+        name: string;
+    };
+    query?: never;
+    url: '/api/v1/media/{name}';
+};
+export type GetMediaErrors = {
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The range is not inside the file
+     */
+    416: unknown;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type GetMediaError = GetMediaErrors[keyof GetMediaErrors];
+export type GetMediaResponses = {
+    /**
+     * The file
+     */
+    200: Blob | File;
+    /**
+     * The requested byte range
+     */
+    206: Blob | File;
+};
+export type GetMediaResponse = GetMediaResponses[keyof GetMediaResponses];
+export type PutMediaData = {
+    body: Blob | File;
+    path: {
+        /**
+         * The tag's name, percent-encoded: `Languages%3A%3AGerman` is `Languages::German`.
+         */
+        name: string;
+    };
+    query?: never;
+    url: '/api/v1/media/{name}';
+};
+export type PutMediaErrors = {
+    /**
+     * The file name cannot be decoded (`invalid_media_name`), or the body is not as long as `Content-Length` says (`length_mismatch`)
+     */
+    400: ApiError;
+    /**
+     * The key lacks the `write` scope, the account is suspended or unverified, the file would take the storage over its quota (`over_quota`), or the collection already holds the most file names it may (`media_entry_limit`)
+     */
+    403: ApiError;
+    /**
+     * No Content-Length header (length_required)
+     */
+    411: unknown;
+    /**
+     * A media file is larger than 100 MiB (`payload_too_large`).
+     */
+    413: ApiError;
+    /**
+     * The name is not one Anki clients keep as it is (`invalid_media_name`), or the file is empty (`empty_file`)
+     */
+    422: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type PutMediaError = PutMediaErrors[keyof PutMediaErrors];
+export type PutMediaResponses = {
+    /**
+     * The file replaced one, or the bytes were the same
+     */
+    200: MediaPutResult;
+    /**
+     * The file was created
+     */
+    201: MediaPutResult;
+};
+export type PutMediaResponse = PutMediaResponses[keyof PutMediaResponses];
+export type ListCardsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * A search, written in Anki's search syntax (the Searching chapter of the Anki manual): the same text you would type in the browser. Words match note text; `-` negates; `or`, `and` and parentheses combine; quotes group. Fields: `front:dog`, `front:*og`, `front:re:^d`, `*:text`, `nc:cafe` (ignore accents), `sc:text` (inside clozes), `re:regex`, `w:word`, `dupe:notetypeId,text`. Notes and cards: `deck:`, `note:`, `card:`, `tag:`, `preset:`, `flag:`, `nid:`, `cid:`, `is:new|learn|review|due|suspended|buried|buried-manually|buried-sibling`. Time: `added:`, `edited:`, `introduced:`, `rated:days[:button]`, `resched:`. Properties: `prop:ivl>=21`, `reps`, `lapses`, `ease`, `due`, `pos`, `rated`, and FSRS `s`, `d`, `r`; `prop:cdn:key>1`, `prop:cds:key=x` and `has-cd:key` for custom data. A search that Anki would refuse is `400 invalid_input` with Anki's own explanation. Differences from desktop Anki: regular expressions run on the RE2 engine (a `(?x)` flag, class set operations such as `[a-z&&[^aeiou]]`, backreferences and `\Q..\E` are `400 invalid_input`, and `\b` uses ASCII word characters, so use `w:` for Unicode words), and a search may be at most 1000 characters and 50 terms.
+         */
+        q?: string;
+        /**
+         * Only items that belong to this deck.
+         */
+        deckId?: number;
+        /**
+         * Only cards made from this note.
+         */
+        noteId?: number;
+        /**
+         * The id of the last item on the previous page, which is its `nextCursor`. Leave it out for the first page.
+         */
+        cursor?: string;
+        /**
+         * Page size, from 1 to 100. Defaults to 50.
+         */
+        limit?: number;
+    };
+    url: '/api/v1/cards';
+};
+export type ListCardsErrors = {
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type ListCardsError = ListCardsErrors[keyof ListCardsErrors];
+export type ListCardsResponses = {
+    /**
+     * Paginated list of cards
+     */
+    200: {
+        /**
+         * This page of cards, in ascending id order.
+         */
+        cards: Array<Card>;
+        /**
+         * Send this as `cursor` to get the next page. `null` when the search is complete. While it is not `null` the page may hold fewer than `limit` cards, or none.
+         */
+        nextCursor: string | null;
+    };
+};
+export type ListCardsResponse = ListCardsResponses[keyof ListCardsResponses];
+export type UpdateCardsBatchData = {
+    body: {
+        /**
+         * The cards to change, 1 to 1000. Repeats are ignored.
+         */
+        ids: Array<number>;
+        /**
+         * The change, shaped like the body of [Edit a card](#updateCard).
+         */
+        patch: UpdateCardInput;
+        /**
+         * Write all or nothing: one refused card means nothing is written (`422`).
+         */
+        atomic?: boolean;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/cards/batch-update';
+};
+export type UpdateCardsBatchErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The body failed validation (`validation_error`), or the call was `atomic` and an entry was refused: then the body is the usual batch answer with every entry's `error`, and nothing was written.
+     */
+    422: ApiError | CreateNotesBatchResult | UpdateNotesBatchResult | UpdateCardsBatchResult;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+    /**
+     * Other batch operations are using the server. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    503: ApiError;
+};
+export type UpdateCardsBatchError = UpdateCardsBatchErrors[keyof UpdateCardsBatchErrors];
+export type UpdateCardsBatchResponses = {
+    /**
+     * Every card was handled; see `results`
+     */
+    200: UpdateCardsBatchResult;
+};
+export type UpdateCardsBatchResponse = UpdateCardsBatchResponses[keyof UpdateCardsBatchResponses];
+export type DeleteCardsBatchData = {
+    body: {
+        /**
+         * The cards to delete, 1 to 1000.
+         */
+        ids: Array<number>;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/cards/batch-delete';
+};
+export type DeleteCardsBatchErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * The key lacks the scope, the account is suspended or its email unverified, the account is over its storage quota (`over_quota`; deleting is still allowed), or a destructive schema change is switched off (`destructive_change_disabled`).
+     */
+    403: ApiError;
+    /**
+     * The body does not match the earlier request that used this `Idempotency-Key` (`idempotency_conflict`), or the body failed validation (`validation_error`).
+     */
+    422: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+    /**
+     * Other batch operations are using the server. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    503: ApiError;
+};
+export type DeleteCardsBatchError = DeleteCardsBatchErrors[keyof DeleteCardsBatchErrors];
+export type DeleteCardsBatchResponses = {
+    /**
+     * The cards that existed were deleted
+     */
+    200: {
+        /**
+         * How many cards were deleted.
+         */
+        deleted: number;
+        /**
+         * The cards that were deleted.
+         */
+        deletedCardIds: Array<number>;
+        /**
+         * Notes that were deleted because their last card went.
+         */
+        deletedNoteIds: Array<number>;
+        /**
+         * Ids that did not exist and were ignored.
+         */
+        missingCardIds: Array<number>;
+    };
+};
+export type DeleteCardsBatchResponse = DeleteCardsBatchResponses[keyof DeleteCardsBatchResponses];
+export type DeleteCardData = {
+    body?: never;
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/cards/{id}';
+};
+export type DeleteCardErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type DeleteCardError = DeleteCardErrors[keyof DeleteCardErrors];
+export type DeleteCardResponses = {
+    /**
+     * Card deleted
+     */
+    200: {
+        /**
+         * `true` when the card was deleted.
+         */
+        ok: boolean;
+        /**
+         * The card that was deleted.
+         */
+        deletedCardIds: Array<number>;
+        /**
+         * The note, if the deleted card was its last one.
+         */
+        deletedNoteIds: Array<number>;
+    };
+};
+export type DeleteCardResponse = DeleteCardResponses[keyof DeleteCardResponses];
+export type GetCardData = {
+    body?: never;
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/cards/{id}';
+};
+export type GetCardErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type GetCardError = GetCardErrors[keyof GetCardErrors];
+export type GetCardResponses = {
+    /**
+     * Card details
+     */
+    200: Card;
+};
+export type GetCardResponse = GetCardResponses[keyof GetCardResponses];
+export type UpdateCardData = {
+    body: {
+        deckId?: number;
+        flag?: number;
+        suspended?: boolean;
+        buried?: boolean;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/cards/{id}';
+};
+export type UpdateCardErrors = {
+    /**
+     * The request was understood but is not valid, for example an unknown deck or a `fields` key that names no field of the note type. The code is `invalid_input`, `deck_error` or `card_type_error`.
+     */
+    400: ApiError;
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The body does not match the earlier request that used this `Idempotency-Key` (`idempotency_conflict`), or the body failed validation (`validation_error`).
+     */
+    422: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type UpdateCardError = UpdateCardErrors[keyof UpdateCardErrors];
+export type UpdateCardResponses = {
+    /**
+     * Card updated
+     */
+    200: {
+        /**
+         * `false` when nothing differed, so nothing was written.
+         */
+        changed: boolean;
+        /**
+         * The card as stored after the change.
+         */
+        card: Card;
+    };
+};
+export type UpdateCardResponse = UpdateCardResponses[keyof UpdateCardResponses];
+export type RenderCardData = {
+    body?: never;
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * `json` (default) or `html` for one complete, sandboxed HTML document.
+         */
+        format?: 'json' | 'html';
+        /**
+         * What the learner typed, for a `{{type:Field}}` comparison. At most 1000 characters.
+         */
+        typedAnswer?: string;
+        /**
+         * An `http(s)` URL prefix. Media file names in the card are turned into this prefix plus the URL-encoded name.
+         */
+        mediaBaseUrl?: string;
+    };
+    url: '/api/v1/cards/{id}/render';
+};
+export type RenderCardErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The card's template has a syntax error or refers to a field that does not exist (`render_error`).
+     */
+    422: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type RenderCardError = RenderCardErrors[keyof RenderCardErrors];
+export type RenderCardResponses = {
+    /**
+     * The rendered card
+     */
+    200: RenderedCard;
+};
+export type RenderCardResponse = RenderCardResponses[keyof RenderCardResponses];
+export type GetCardSchedulingData = {
+    body?: never;
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/cards/{id}/scheduling';
+};
+export type GetCardSchedulingErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The change alters the collection's schema and needs `?acceptFullSync=true` (`full_sync_required`), or the card is in a state that does not allow this (`card_state_error`: suspended, buried, in a filtered deck, or an unsupported scheduler).
+     */
+    409: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type GetCardSchedulingError = GetCardSchedulingErrors[keyof GetCardSchedulingErrors];
+export type GetCardSchedulingResponses = {
+    /**
+     * What each answer would do
+     */
+    200: CardScheduling;
+};
+export type GetCardSchedulingResponse = GetCardSchedulingResponses[keyof GetCardSchedulingResponses];
+export type AnswerCardData = {
+    body: {
+        rating: 'again' | 'hard' | 'good' | 'easy' | number;
+        timeTakenMs?: number;
+    };
+    headers?: {
+        /**
+         * Any unique string, such as a UUID. Send the same key when you retry a write: the first answer is replayed (marked `X-Idempotent-Replay: true`) instead of doing the work twice. Keys are remembered for 24 hours. Reusing a key with a different request is `422 idempotency_conflict`.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * The numeric id, as returned by the list endpoint or when it was created.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/api/v1/cards/{id}/answer';
+};
+export type AnswerCardErrors = {
+    /**
+     * No deck, note, note type or card has that id.
+     */
+    404: ApiError;
+    /**
+     * The change alters the collection's schema and needs `?acceptFullSync=true` (`full_sync_required`), or the card is in a state that does not allow this (`card_state_error`: suspended, buried, in a filtered deck, or an unsupported scheduler).
+     */
+    409: ApiError;
+    /**
+     * The body does not match the earlier request that used this `Idempotency-Key` (`idempotency_conflict`), or the body failed validation (`validation_error`).
+     */
+    422: ApiError;
+    /**
+     * Another write or an Anki sync is using the collection. Wait the number of seconds in `Retry-After` and retry; nothing was changed.
+     */
+    423: ApiError;
+    /**
+     * The plan's rate limit is used up: a limit per minute on every plan, and a limit per day on Free. Nothing was changed. Wait Retry-After seconds and send the same request again.
+     */
+    429: ApiError;
+};
+export type AnswerCardError = AnswerCardErrors[keyof AnswerCardErrors];
+export type AnswerCardResponses = {
+    /**
+     * The card was scheduled and the review logged
+     */
+    200: {
+        /**
+         * Id of the review-log entry, a millisecond timestamp.
+         */
+        revlogId: number;
+        /**
+         * `true` when this answer made the card a leech.
+         */
+        leeched: boolean;
+        /**
+         * Other cards of the same note that were buried until tomorrow.
+         */
+        buriedSiblingIds: Array<number>;
+        /**
+         * The card as stored after the answer.
+         */
+        card: Card;
+    };
+};
+export type AnswerCardResponse = AnswerCardResponses[keyof AnswerCardResponses];