@ankinize/sdk 0.0.0-stage → 0.1.0

package/dist/gen/sdk.gen.d.ts

@@ -0,0 +1,504 @@
+import { type Client, type ClientMeta, type Options as Options2, type RequestResult, type TDataShape } from './client/index.js';
+import type { AnswerCardErrors, AnswerCardResponses, CreateDeckErrors, CreateDeckResponses, CreateNoteErrors, CreateNoteInput, CreateNoteResponses, CreateNotesBatchErrors, CreateNotesBatchResponses, CreateNoteTypeErrors, CreateNoteTypeResponses, CreateTagErrors, CreateTagResponses, CreateTagsBatchErrors, CreateTagsBatchResponses, DeleteCardErrors, DeleteCardResponses, DeleteCardsBatchErrors, DeleteCardsBatchResponses, DeleteDeckErrors, DeleteDeckResponses, DeleteMediaErrors, DeleteMediaResponses, DeleteNoteErrors, DeleteNoteResponses, DeleteNotesBatchErrors, DeleteNotesBatchResponses, DeleteNoteTypeErrors, DeleteNoteTypeResponses, DeleteTagErrors, DeleteTagResponses, DeleteTagsBatchErrors, DeleteTagsBatchResponses, GetCardErrors, GetCardResponses, GetCardSchedulingErrors, GetCardSchedulingResponses, GetDeckErrors, GetDeckResponses, GetMediaErrors, GetMediaResponses, GetNoteErrors, GetNoteResponses, GetNoteTypeErrors, GetNoteTypeResponses, GetStatsErrors, GetStatsResponses, GetStudyQueueErrors, GetStudyQueueResponses, GetTagErrors, GetTagResponses, ListCardsErrors, ListCardsResponses, ListDecksErrors, ListDecksResponses, ListMediaErrors, ListMediaResponses, ListNotesErrors, ListNotesResponses, ListNoteTypesErrors, ListNoteTypesResponses, ListTagsErrors, ListTagsResponses, PutMediaErrors, PutMediaResponses, RenameDeckErrors, RenameDeckResponses, RenameTagErrors, RenameTagResponses, RenderCardErrors, RenderCardResponses, UpdateCardErrors, UpdateCardInput, UpdateCardResponses, UpdateCardsBatchErrors, UpdateCardsBatchResponses, UpdateNoteErrors, UpdateNoteResponses, UpdateNotesBatchEntry, UpdateNotesBatchErrors, UpdateNotesBatchResponses, UpdateNoteTypeErrors, UpdateNoteTypeResponses, UpdateTagsBatchEntry, UpdateTagsBatchErrors, UpdateTagsBatchResponses } from './types.gen.js';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+/**
+ * List all decks
+ *
+ * Returns every deck in the collection, including the built-in `Default` deck and nested decks. A nested deck's name is its full path, such as `Languages::German`.
+ */
+export declare const listDecks: <ThrowOnError extends boolean = true>(options?: Options<never, ThrowOnError>) => RequestResult<ListDecksResponses, ListDecksErrors, ThrowOnError, 'data'>;
+/**
+ * Create a deck
+ *
+ * Creates a deck and returns it. Use `::` in the name to nest it under a parent, for example `Languages::German`.
+ */
+export declare const createDeck: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    name: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<CreateDeckResponses, CreateDeckErrors, ThrowOnError, 'data'>;
+/**
+ * Delete a deck and its subdecks
+ *
+ * Deletes the deck, all of its subdecks and every card in them. Notes left with no cards are removed too.
+ *
+ * This cannot be undone. The response lists exactly which decks and cards were removed. Deleting is still allowed while the account is over its storage quota.
+ */
+export declare const deleteDeck: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    id: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<DeleteDeckResponses, DeleteDeckErrors, ThrowOnError, 'data'>;
+/**
+ * Get a deck by ID
+ *
+ * Returns one deck by its numeric id.
+ */
+export declare const getDeck: <ThrowOnError extends boolean = true>(parameters: {
+    id: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<GetDeckResponses, GetDeckErrors, ThrowOnError, 'data'>;
+/**
+ * Rename a deck
+ *
+ * Changes a deck's name. The deck keeps its id and its cards, and its subdecks are renamed with it.
+ */
+export declare const renameDeck: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    id: number;
+    name: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<RenameDeckResponses, RenameDeckErrors, ThrowOnError, 'data'>;
+/**
+ * List notes with pagination and filters
+ *
+ * Returns notes in ascending id order, one page at a time. Filters combine with AND.
+ *
+ * To read the next page, send the previous response's `nextCursor` as `cursor`. `nextCursor` is `null` on the last page.
+ */
+export declare const listNotes: <ThrowOnError extends boolean = true>(parameters?: {
+    deckId?: number;
+    notetypeId?: number;
+    tag?: string;
+    cursor?: string;
+    limit?: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<ListNotesResponses, ListNotesErrors, ThrowOnError, 'data'>;
+/**
+ * Create a note and generate its cards
+ *
+ * Creates a note and generates its cards from the note type's templates.
+ *
+ * Name the note type with `notetypeName` and the deck with `deckName` (compared ignoring case; a nested deck is `Languages::German`), or send `notetypeId` and `deckId` instead. Exactly one of `notetypeName` and `notetypeId` is needed; without a deck the note goes to the `Default` deck. A name that matches nothing is `404`.
+ *
+ * `fields` is an object with one entry per field of the note type, keyed by the field's name in camelCase: `Back Extra` is `backExtra`. Each field of a note type shows its `key` in [Get a note type](#getNoteType). The field's exact name works as a key too. A field you leave out is empty; a key that names no field is `400 invalid_input` and lists the valid keys.
+ *
+ * Send a `guid` only when you import notes from somewhere else and need to keep a stable identity; otherwise one is generated. All fields together may not exceed 5 MiB.
+ */
+export declare const createNote: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    notetypeName?: string;
+    notetypeId?: number;
+    deckName?: string;
+    deckId?: number;
+    fields: {
+        [key: string]: string;
+    };
+    tags?: Array<string>;
+    guid?: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<CreateNoteResponses, CreateNoteErrors, ThrowOnError, 'data'>;
+/**
+ * Create many notes in one call
+ *
+ * Creates up to 200 notes in one call. It does what [Create a note](#createNote) does for each entry (also naming note types and decks by name), but in one transaction and with the note types, decks and tags looked up once, so importing is far faster than one request per note.
+ *
+ * The answer is `200` with one entry in `results` per note you sent, in the same order (`index`). An entry the collection refuses, such as an unknown deck or a key that names no field, is reported as `ok: false` with an `error`, and the others are still written. Send `atomic: true` to write all or nothing: if any entry is refused, nothing is written and the answer is `422` with the same body.
+ *
+ * A batch counts as one request per 10 notes (at least one) against your plan's rate limit. At most 2 batches run at once on the server; when it is busy the answer is `503` with `Retry-After`, and nothing was changed.
+ */
+export declare const createNotesBatch: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    notes: Array<CreateNoteInput>;
+    atomic?: boolean;
+}, options?: Options<never, ThrowOnError>) => RequestResult<CreateNotesBatchResponses, CreateNotesBatchErrors, ThrowOnError, 'data'>;
+/**
+ * Edit many notes in one call
+ *
+ * Edits up to 200 notes in one call. It does what [Edit a note](#updateNote) does for each entry, but in one transaction with note types, decks and tags looked up once. Each entry names a note by `id` and may send `fields`, `tags`, or the tag edits `addTags` and `removeTags`; what it leaves out stays as it was. `tags` replaces all tags and can not be sent with `addTags` or `removeTags`. `removeTags` works as in Anki: a tag is matched ignoring case, and removing `lang` also removes `lang::de` and the other tags below it (`*` is not a wildcard). A note may appear once per call.
+ *
+ * The answer is `200` with one entry in `results` per entry you sent, in the same order (`index`). An entry the collection refuses, such as an unknown note or the wrong number of fields, is reported as `ok: false` with an `error`, and the others are still written. Send `atomic: true` to write all or nothing: if any entry is refused, nothing is written and the answer is `422` with the same body. `changed` counts notes that differed from what was stored.
+ *
+ * A batch counts as one request per 10 entries (at least one) against your plan's rate limit.
+ */
+export declare const updateNotesBatch: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    updates: Array<UpdateNotesBatchEntry>;
+    atomic?: boolean;
+}, options?: Options<never, ThrowOnError>) => RequestResult<UpdateNotesBatchResponses, UpdateNotesBatchErrors, ThrowOnError, 'data'>;
+/**
+ * Delete many notes in one call
+ *
+ * Deletes up to 1000 notes and every card made from them, in one transaction. Ids that do not exist are not an error; they are listed in `missingNoteIds`. This cannot be undone. Deleting is still allowed while the account is over its storage quota.
+ *
+ * A batch counts as one request per 10 ids (at least one) against your plan's rate limit.
+ */
+export declare const deleteNotesBatch: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    ids: Array<number>;
+}, options?: Options<never, ThrowOnError>) => RequestResult<DeleteNotesBatchResponses, DeleteNotesBatchErrors, ThrowOnError, 'data'>;
+/**
+ * Delete a note and its cards
+ *
+ * Deletes a note and every card made from it. This cannot be undone. Deleting is still allowed while the account is over its storage quota.
+ */
+export declare const deleteNote: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    id: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<DeleteNoteResponses, DeleteNoteErrors, ThrowOnError, 'data'>;
+/**
+ * Get note by ID with cards
+ *
+ * Returns one note, including the cards it produced.
+ */
+export declare const getNote: <ThrowOnError extends boolean = true>(parameters: {
+    id: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<GetNoteResponses, GetNoteErrors, ThrowOnError, 'data'>;
+/**
+ * Update note fields or tags
+ *
+ * Changes a note's fields, its tags, or both. Anything you leave out stays as it was, including each field missing from `fields`: send only the fields that change. If the new field content makes a template produce a card it did not before, the new cards are returned in `newCards`.
+ *
+ * `changed` is `false` when the request matched what was already stored, and nothing is written.
+ */
+export declare const updateNote: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    id: number;
+    fields?: {
+        [key: string]: string;
+    };
+    tags?: Array<string>;
+}, options?: Options<never, ThrowOnError>) => RequestResult<UpdateNoteResponses, UpdateNoteErrors, ThrowOnError, 'data'>;
+/**
+ * List all note types
+ *
+ * Returns the id and name of every note type. Use [Get a note type](#getNoteType) for its fields and templates.
+ */
+export declare const listNoteTypes: <ThrowOnError extends boolean = true>(options?: Options<never, ThrowOnError>) => RequestResult<ListNoteTypesResponses, ListNoteTypesErrors, ThrowOnError, 'data'>;
+/**
+ * Create note type (stock or custom)
+ *
+ * Creates a note type, either from one of Anki's stock designs or from your own fields and templates.
+ *
+ * Send `stock` (`basic`, `basic-and-reversed`, `basic-optional-reversed`, `basic-type-in-answer`, `cloze` or `image-occlusion`) to start from a stock design, and optionally `name` to rename it. Or send `fields` and `templates` to define it yourself.
+ */
+export declare const createNoteType: <ThrowOnError extends boolean = true>(parameters?: {
+    idempotencyKey?: string;
+    stock?: string;
+    name?: string;
+    kind?: 'normal' | 'cloze';
+    fields?: Array<{
+        [key: string]: unknown;
+    }>;
+    templates?: Array<{
+        [key: string]: unknown;
+    }>;
+    css?: string;
+    sortFieldIdx?: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<CreateNoteTypeResponses, CreateNoteTypeErrors, ThrowOnError, 'data'>;
+/**
+ * Delete a note type
+ *
+ * Deletes a note type and every note that uses it.
+ *
+ * This changes the collection's schema, so it needs `?acceptFullSync=true` (otherwise `409 full_sync_required`) and *Allow destructive schema changes via API* turned on under Settings → Developer (otherwise `403 destructive_change_disabled`).
+ */
+export declare const deleteNoteType: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    id: number;
+    acceptFullSync?: boolean;
+}, options?: Options<never, ThrowOnError>) => RequestResult<DeleteNoteTypeResponses, DeleteNoteTypeErrors, ThrowOnError, 'data'>;
+/**
+ * Get note type details with fields and templates
+ *
+ * Returns a note type with its fields and card templates, its CSS and its sort field.
+ */
+export declare const getNoteType: <ThrowOnError extends boolean = true>(parameters: {
+    id: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<GetNoteTypeResponses, GetNoteTypeErrors, ThrowOnError, 'data'>;
+/**
+ * Update note type fields, templates, or styling
+ *
+ * Changes a note type's name, CSS, sort field, fields or templates.
+ *
+ * Adding, reordering or renaming fields and templates is safe. Removing a field or template, or changing which fields a template needs, changes the collection's schema, so every device has to download the whole collection again on its next sync (a *full sync*). The request is refused with `409 full_sync_required` until you add `?acceptFullSync=true`.
+ *
+ * Removing a field or template also needs *Allow destructive schema changes via API* turned on under Settings → Developer, or the answer is `403 destructive_change_disabled`.
+ */
+export declare const updateNoteType: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    id: number;
+    acceptFullSync?: boolean;
+    name?: string;
+    css?: string;
+    sortFieldIdx?: number;
+    fields?: Array<{
+        [key: string]: unknown;
+    }>;
+    templates?: Array<{
+        [key: string]: unknown;
+    }>;
+}, options?: Options<never, ThrowOnError>) => RequestResult<UpdateNoteTypeResponses, UpdateNoteTypeErrors, ThrowOnError, 'data'>;
+/**
+ * Get the study queue of a deck
+ *
+ * Returns the cards Anki would show next in a deck, in the order it would show them: the deck (and its subdecks) is searched for learning cards due now, then reviews and day-learning cards, then new cards, under the daily limits of every deck preset and deck (including *New cards ignore review limit* and *Apply all parent limits*), with new-card gather and sort order, review order, FSRS orders, burying of siblings and the mixes of new cards and day-learning cards with reviews. The result matches the desktop client's queue for the same collection and moment.
+ *
+ * `counts` is what Anki shows above the buttons (new, learning, review). `cards` holds the first `limit` cards, each with a `kind` of `new`, `learning` or `review`; `total` is the length of the whole queue. Learning cards that are due within the preset's learn-ahead limit are listed at the end. Nothing is written, so asking again before you answer gives the same queue; after `POST /api/v1/cards/{id}/answer` ask again.
+ *
+ * Without `deckId` the collection's current deck is used. Only the v3 scheduler is supported (`409 card_state_error` otherwise). A filtered deck is queued with unlimited counts, in the order it was built in Anki (its cards keep that position).
+ */
+export declare const getStudyQueue: <ThrowOnError extends boolean = true>(parameters?: {
+    deckId?: number;
+    limit?: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<GetStudyQueueResponses, GetStudyQueueErrors, ThrowOnError, 'data'>;
+/**
+ * List all tags
+ *
+ * Returns every tag in the collection, sorted by name. A nested tag keeps Anki's `::` separator, such as `Languages::German`; searching `tag:Languages` also finds the notes tagged with the nested ones.
+ */
+export declare const listTags: <ThrowOnError extends boolean = true>(options?: Options<never, ThrowOnError>) => RequestResult<ListTagsResponses, ListTagsErrors, ThrowOnError, 'data'>;
+/**
+ * Create a tag
+ *
+ * Creates a tag without putting it on a note, as Anki registers a tag when a note brings it. A name that is already used (ignoring case) answers `200` with `created: false` and the spelling that is stored, so sending it twice is safe. A nested name keeps the spelling of a parent that exists, as in Anki.
+ *
+ * A tag no note carries is removed by Anki's *Check Database* and *Clear Unused Tags*.
+ */
+export declare const createTag: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    name: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<CreateTagResponses, CreateTagErrors, ThrowOnError, 'data'>;
+/**
+ * Delete a tag
+ *
+ * Removes a tag and the tags nested under it from every note and from the list. The notes keep everything else. This cannot be undone. Deleting is still allowed while the account is over its storage quota.
+ */
+export declare const deleteTag: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    name: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<DeleteTagResponses, DeleteTagErrors, ThrowOnError, 'data'>;
+/**
+ * Get a tag by name
+ *
+ * Returns a tag and `noteCount`, the notes that carry it or one of its nested tags (the notes `tag:name` finds). A tag exists when it is in the list, when a nested tag is, or when a note carries it. The `name` in the path is the tag, percent-encoded, and is compared ignoring case.
+ */
+export declare const getTag: <ThrowOnError extends boolean = true>(parameters: {
+    name: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<GetTagResponses, GetTagErrors, ThrowOnError, 'data'>;
+/**
+ * Rename a tag
+ *
+ * Renames a tag and every tag nested under it on all notes: renaming `Languages` to `Lang` makes `Languages::German` into `Lang::German`. The notes that change get a new modification time, so they sync. If the new name is already a tag, the two are merged, and a note that ends up with the tag twice keeps it once. Renaming a tag that no note carries renames it in the list.
+ *
+ * `notes` is how many notes were looked at and changed.
+ */
+export declare const renameTag: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    name: string;
+    newName: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<RenameTagResponses, RenameTagErrors, ThrowOnError, 'data'>;
+/**
+ * Create many tags in one call
+ *
+ * Creates up to 200 tags in one call, in one transaction. It does what [Create a tag](#createTag) does for each name. The answer is `200` with one entry in `results` per name, in order; a name that is refused (such as one with a space) is `ok: false` with an `error` and the others are still created. Send `atomic: true` to write all or nothing: then the answer is `422` with the same body.
+ *
+ * A batch counts as one request per 10 names against your plan's rate limit.
+ */
+export declare const createTagsBatch: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    names: Array<string>;
+    atomic?: boolean;
+}, options?: Options<never, ThrowOnError>) => RequestResult<CreateTagsBatchResponses, CreateTagsBatchErrors, ThrowOnError, 'data'>;
+/**
+ * Rename many tags in one call
+ *
+ * Renames up to 200 tags in one call, in one pass over the notes. Each entry names a tag by `name` and gives its `newName`, as [Rename a tag](#renameTag) does. Two entries may use the same `newName` (that merges the tags), but an entry that touches another one (a `name` that is, contains or lies inside another entry's `name` or `newName`) is refused with `invalid_input`, because the result would depend on the order. Entries are reported in `results` as in [Create many notes](#createNotesBatch); `atomic: true` writes all or nothing.
+ */
+export declare const updateTagsBatch: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    updates: Array<UpdateTagsBatchEntry>;
+    atomic?: boolean;
+}, options?: Options<never, ThrowOnError>) => RequestResult<UpdateTagsBatchResponses, UpdateTagsBatchErrors, ThrowOnError, 'data'>;
+/**
+ * Delete many tags in one call
+ *
+ * Deletes up to 1000 tags, with the tags nested under them, from every note and from the list, in one transaction. Names that do not exist are not an error; they are listed in `missingNames`. This cannot be undone. Deleting is still allowed while the account is over its storage quota.
+ */
+export declare const deleteTagsBatch: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    names: Array<string>;
+}, options?: Options<never, ThrowOnError>) => RequestResult<DeleteTagsBatchResponses, DeleteTagsBatchErrors, ThrowOnError, 'data'>;
+/**
+ * Get the statistics of a search
+ *
+ * Returns the graphs of Anki's statistics screen for the cards a search matches (`q`, default every card) and the last `days` days of review history (`0`, the default, is all of it). The numbers are Anki's: the same counts, buckets and averages the desktop client draws, computed from the review log and the cards in place. Nothing is copied into another database. A request reads the review log once, so a big collection takes a moment; one that takes longer than 20 seconds is refused with `400 invalid_input` (narrow the search or the days). The server keeps the graphs of a search in memory for up to five minutes, and never past the end of the day, while the collection is unchanged, so a repeat request is answered without reading the collection again; any change to the collection ends that.
+ *
+ * Days are counted from the end of the current day, so `0` is today, `-1` yesterday and `1` tomorrow; a day starts at the collection's `rollover` hour and is read in its `localOffset` (UTC when unset), as `timing` says. `buttons`, `hours` and `trueRetention` count answers over a month, three months, a year and all time. `cardCounts` counts cards by kind, with suspended and buried cards counted separately or together. `eases` (SM-2) and `difficulty`, `stability` and `retrievability` (FSRS) cover the cards that have the data; `fsrs` says whether the collection has FSRS turned on. `retrievability` is the chance of recalling each card now, from its memory state and the time since its last review. Keys of the count objects are numbers: a day, a percent bin or an interval in days.
+ */
+export declare const getStats: <ThrowOnError extends boolean = true>(parameters?: {
+    q?: string;
+    days?: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<GetStatsResponses, GetStatsErrors, ThrowOnError, 'data'>;
+/**
+ * List media files
+ *
+ * Lists the collection's media files by name, 100 at a time (`limit` up to 1000). `prefix` keeps only the names that start with it. When `nextCursor` is not null, pass it as `cursor` to get the next page. Each item has the file's `size`, its `sha1` and `sha256`, the `contentType` it is served as, and the `usn` of its last change, which is the number the Anki media sync uses.
+ */
+export declare const listMedia: <ThrowOnError extends boolean = true>(parameters?: {
+    prefix?: string;
+    limit?: number;
+    cursor?: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<ListMediaResponses, ListMediaErrors, ThrowOnError, 'data'>;
+/**
+ * Delete a media file
+ *
+ * Deletes the file. Your devices are told on their next media sync, as when a file is deleted in Anki. The storage it used is freed once no other name uses the same bytes. A name that is not there is `404`.
+ */
+export declare const deleteMedia: <ThrowOnError extends boolean = true>(parameters: {
+    name: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<DeleteMediaResponses, DeleteMediaErrors, ThrowOnError, 'data'>;
+/**
+ * Download a media file
+ *
+ * Returns the file's bytes. The type comes from the file name's extension only, never from the bytes, and every response says `X-Content-Type-Options: nosniff` and a `Content-Security-Policy` with `sandbox`, so a file from your collection cannot run script on this origin. Images, audio, video and fonts are shown inline; SVG, PDF and any other type are offered as downloads (`Content-Disposition: attachment`).
+ *
+ * The `ETag` is the file's SHA-256, so `If-None-Match` answers `304`. `Range: bytes=...` (one range) answers `206`, which lets a browser seek in audio and video; a range past the end is `416`.
+ *
+ * Instead of a key, the request may carry the `u`, `exp` and `sig` query parameters of a signed link. A signed link opens that one file for reading until it expires, which is how a card shown in a sandboxed frame loads its pictures: `GET /api/v1/cards/{id}/render` puts such links into the card unless you pass `mediaBaseUrl`. The links last an hour.
+ */
+export declare const getMedia: <ThrowOnError extends boolean = true>(parameters: {
+    Range?: string;
+    name: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<GetMediaResponses, GetMediaErrors, ThrowOnError, 'data'>;
+/**
+ * Store a media file
+ *
+ * Stores the request body as the file, creating it or replacing it. Send the bytes as they are (any `Content-Type`) with a `Content-Length` header; chunked uploads are refused with `411`. A file is at most 100 MiB and not empty.
+ *
+ * The name must be one Anki clients would keep as it is: at most 120 bytes of UTF-8, in Unicode NFC, with none of `[ ] < > : " / ? * ^ \ |` or control characters, no Windows device name (`CON`, `NUL`, `LPT1`...), and not ending in a space or a dot. A client rewrites any other name when it syncs, so the file would never settle between devices; the `422 invalid_media_name` says the name to use. `Thumbs.db` and `.DS_Store` are never synced and are refused as well.
+ *
+ * `201` means the file is new; `200` means it replaced a file (`created` is false) or the bytes were the same (`unchanged` is true, and the `usn` stays). A new or changed file gets the next `usn`, so the media sync sends it to your devices. A file that would take the storage over the quota is `403 over_quota`, and a collection already holding the most file names it may (deleted names count) is `403 media_entry_limit`; replacing a name never adds one.
+ */
+export declare const putMedia: <ThrowOnError extends boolean = true>(parameters: {
+    name: string;
+    body: Blob | File;
+}, options?: Options<never, ThrowOnError>) => RequestResult<PutMediaResponses, PutMediaErrors, ThrowOnError, 'data'>;
+/**
+ * List cards with pagination and filters
+ *
+ * Returns the cards that match a search (`q`; every card when it is empty), in ascending id order, one page at a time. You can also filter by deck or by note. Paginate with `nextCursor` as for notes, with one difference: a search that has to look at every card, such as a regular expression or `prop:s`, stops after about 10,000 cards and returns what it found so far together with a `nextCursor`. A page can therefore hold fewer than `limit` cards, or none, while `nextCursor` is not `null`; keep following it until it is.
+ */
+export declare const listCards: <ThrowOnError extends boolean = true>(parameters?: {
+    q?: string;
+    deckId?: number;
+    noteId?: number;
+    cursor?: string;
+    limit?: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<ListCardsResponses, ListCardsErrors, ThrowOnError, 'data'>;
+/**
+ * Edit many cards in one call
+ *
+ * Applies one change to up to 1000 cards, in one transaction: set a flag, move them to a deck, suspend or bury them. It does what [Edit a card](#updateCard) does for each id, with the same rules for `patch`.
+ *
+ * The answer is `200` with one entry in `results` per distinct id. A card that does not exist, or that sits in a filtered deck and so can not be moved, is reported as `ok: false`, and the others are still changed. Send `atomic: true` to write all or nothing: if any card is refused, nothing is written and the answer is `422` with the same body. `changed` counts the cards that differed from what was stored.
+ *
+ * A batch counts as one request per 10 ids (at least one) against your plan's rate limit.
+ */
+export declare const updateCardsBatch: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    ids: Array<number>;
+    patch: UpdateCardInput;
+    atomic?: boolean;
+}, options?: Options<never, ThrowOnError>) => RequestResult<UpdateCardsBatchResponses, UpdateCardsBatchErrors, ThrowOnError, 'data'>;
+/**
+ * Delete many cards in one call
+ *
+ * Deletes up to 1000 cards in one transaction. A note whose last card is deleted is deleted with it. Ids that do not exist are not an error; they are listed in `missingCardIds`. This cannot be undone. Deleting is still allowed while the account is over its storage quota.
+ *
+ * A batch counts as one request per 10 ids (at least one) against your plan's rate limit.
+ */
+export declare const deleteCardsBatch: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    ids: Array<number>;
+}, options?: Options<never, ThrowOnError>) => RequestResult<DeleteCardsBatchResponses, DeleteCardsBatchErrors, ThrowOnError, 'data'>;
+/**
+ * Delete a card
+ *
+ * Deletes one card. If it was the last card of its note, the note is removed too. This cannot be undone. Deleting is still allowed while the account is over its storage quota.
+ */
+export declare const deleteCard: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    id: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<DeleteCardResponses, DeleteCardErrors, ThrowOnError, 'data'>;
+/**
+ * Get card details by ID
+ *
+ * Returns one card with its scheduling state: queue, due, interval, ease factor, repetitions and lapses.
+ */
+export declare const getCard: <ThrowOnError extends boolean = true>(parameters: {
+    id: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<GetCardResponses, GetCardErrors, ThrowOnError, 'data'>;
+/**
+ * Edit a card
+ *
+ * Changes a card's flag, moves it to another deck, or suspends or buries it. Anything you leave out stays as it was.
+ *
+ * `flag` is 0 (none) to 7. `suspended` and `buried` cannot both be sent. Suspending keeps a card out of review until you send `suspended: false`; burying hides it only until the next day or until you unbury it. A suspended card is never buried. Moving a card clears its FSRS memory state; it is replayed from the review history with the new deck's parameters the next time the card is shown or answered. Cards in a filtered deck can neither be moved nor moved into one (`409 card_state_error`).
+ *
+ * `changed` is `false` when the request matched what was already stored.
+ */
+export declare const updateCard: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    id: number;
+    deckId?: number;
+    flag?: number;
+    suspended?: boolean;
+    buried?: boolean;
+}, options?: Options<never, ThrowOnError>) => RequestResult<UpdateCardResponses, UpdateCardErrors, ThrowOnError, 'data'>;
+/**
+ * Render a card's front and back
+ *
+ * Renders the card as Anki shows it: the note's fields are put into the card template, so the question and the answer are ready to display. The answer includes the question above a divider, as in Anki.
+ *
+ * Everything is sanitized on the server before it is returned: scripts, event handlers, iframes, forms, `javascript:` links and remote styles are removed, and CSS is limited to a safe subset. The result is still *content from your collection*, so display it in a sandboxed `<iframe sandbox>` or `srcdoc` and not straight into your page.
+ *
+ * With `format=json` (the default) you get `question`, `answer` and `css`. With `format=html` you get one complete HTML document, with a `Content-Security-Policy` that allows no script and the `sandbox` directive, which is meant for `<iframe sandbox srcdoc>`: fetch it with your key and put the text in `srcdoc` (an iframe's `src` cannot send the key, and this server refuses to be framed). Media in a card is referred to by file name and listed in `media`. The file names in the question and answer are turned into signed links to `GET /api/v1/media/{name}` that last an hour, so the card shows its pictures and plays its audio from a sandboxed frame; or pass `mediaBaseUrl` (an `http(s)` URL ending in `/`) to have them point at files you host instead.
+ *
+ * **Typing the answer.** For `{{type:Field}}`, `{{type:nc:Field}}` (accents ignored) and `{{type:cloze:Field}}` the question holds `<div class="typeans" data-field="Field"></div>`, where your own input goes. Pass what the learner typed as `typedAnswer` (up to 1000 characters) and the answer shows the comparison Anki shows, computed the same way: a `<code id="typeans">` with the typed text and the expected text as `typeGood`, `typeBad` and `typeMissed` spans around an arrow, in the font and size of the field. The classes carry no colors, so style them in your page. Without `typedAnswer` the answer shows the expected text. A text too long to compare is shown as one change.
+ *
+ * **Formulas.** `\(...\)` and `\[...\]` are returned as written. Anki's `[$]...[/$]` and `[$$]...[/$$]` tags are rewritten to them, and `[latex]...[/latex]` becomes display math; images are not generated, because that needs a TeX installation. `math` is true when the question or the answer holds a formula. Typeset it in your page with MathJax 3 after inserting the HTML (`format=html` allows no script, so a formula stays as text there). TeX that is not math, such as packages or TikZ, is not supported.
+ *
+ * A template that cannot be rendered is `422 render_error`.
+ */
+export declare const renderCard: <ThrowOnError extends boolean = true>(parameters: {
+    id: number;
+    format?: 'json' | 'html';
+    typedAnswer?: string;
+    mediaBaseUrl?: string;
+}, options?: Options<never, ThrowOnError>) => RequestResult<RenderCardResponses, RenderCardErrors, ThrowOnError, 'data'>;
+/**
+ * Preview the four answer buttons
+ *
+ * Shows what each answer button would do, without answering: the time until the card would next be due after Again, Hard, Good and Easy. This is the preview Anki shows above its buttons.
+ *
+ * Only the v3 scheduler is supported. The card must be answerable: not suspended or buried (`409 card_state_error`). A card in a filtered deck is previewed as Anki does: in a deck that reschedules, the buttons are the home deck preset's, and a review that comes before it was due is scheduled from the days it was early; in a deck that does not reschedule, the buttons are the preview delays (Again, Hard and Good come back after the deck's delays, a delay of 0 ends the preview, and Easy always ends it) and show `0` seconds when they end it.
+ *
+ * Review intervals are fuzzed and load balanced like Anki's: the day is drawn within the fuzz range, weighted towards days with fewer cards of the same preset due, the preset's Easy Days and (if it buries siblings) days away from the card's siblings. The draw is fixed by the card and its review count, so the preview, the answer and a repeat of either agree.
+ */
+export declare const getCardScheduling: <ThrowOnError extends boolean = true>(parameters: {
+    id: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<GetCardSchedulingResponses, GetCardSchedulingErrors, ThrowOnError, 'data'>;
+/**
+ * Answer (review) a card
+ *
+ * Answers a card, the same as pressing a button in Anki's reviewer. The card is rescheduled with the deck preset's v3 scheduler (or FSRS when the preset turns it on), a review-log entry is written, the deck's daily counts go up, and siblings are buried if the preset says so. A card that reaches the leech threshold gets the `leech` tag and, if the preset says so, is suspended.
+ *
+ * `rating` is `again`, `hard`, `good` or `easy` (or 1 to 4). `timeTakenMs` is how long the learner looked at the card, capped by the preset. Send an `Idempotency-Key` so a retry does not answer twice.
+ *
+ * The card must not be suspended or buried, and the collection must use the v3 scheduler; otherwise the answer is `409 card_state_error`. A card in a filtered deck is answered as Anki does. The preset, the answer-time cap and burying come from the card's home deck, the daily counts go to the filtered deck and its parents, and the review log records an answer given before the card was due (or in a deck that does not reschedule) with type 3 (*filtered*). In a deck that reschedules, a review card that is passed returns to its home deck, and a learning card stays in the filtered deck until it graduates; in a deck that does not reschedule, nothing is rescheduled: Again, Hard and Good bring the card back after the deck's preview delay, and the card returns to its home deck in its old state when the preview ends. The legacy schedulers are not supported. A card that has no FSRS memory state yet (for example one that was just moved into an FSRS deck) gets one replayed from its review history, as Anki does, and from its SM-2 ease and interval when the history is too short.
+ *
+ * The load balancer is applied to review intervals as in Anki (see `GET /api/v1/cards/{id}/scheduling`). It reads the cards due in the next 99 days when the card is answered (Anki reads them once when it builds a queue), and the weekday used for Easy Days is taken in the collection's `localOffset` (UTC when unset).
+ */
+export declare const answerCard: <ThrowOnError extends boolean = true>(parameters: {
+    idempotencyKey?: string;
+    id: number;
+    rating: 'again' | 'hard' | 'good' | 'easy' | number;
+    timeTakenMs?: number;
+}, options?: Options<never, ThrowOnError>) => RequestResult<AnswerCardResponses, AnswerCardErrors, ThrowOnError, 'data'>;