This is the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

Anki as code

Export and reconcile Anki collections as TOML

Anki as code exports collections as protobuf-backed TOML, plans changes, and reconciles them through Anki’s native API. It accepts modern .colpkg archives containing collection.anki21b and offline collection databases such as collection.anki2. Keep Anki and other writers closed during export, state operations, apply, and build. Plan, config dump, and state dump use stdout; status and errors use stderr.

Configuration paths identify objects, similar to Terraform. Native IDs live in Anki and collection-backed state; note GUIDs remain Anki metadata. New files create new objects; explicit moves retain existing identities and review progress. Apply/build leave all configuration files unchanged. New notes and their note types can be created in the same apply, without generating or writing identities into source.

Collection operations live under col (alias collection): col export, col plan, col apply, col build, and col state. The namespace flag --state-key belongs to this group. Text-only operations use config (alias conf), such as conf dump. Collection source flags remain specific to each operation: --collection for existing collections and --base for builds.

The CLI reference has a short index and one child page per root subcommand, each containing its complete nested help, including the generated Anki API tree. Bazel generates these pages from the Cobra definitions with tools/generate_cli_docs and packages the hierarchy with the documentation; generated Markdown is not checked in. Build it with bazel_agent bazel build //projects/anki_as_code/docs:cli_reference.

The Linux x86_64 application links the Rust server into its executable. Collection operations launch the same executable with server serve and communicate over stdio. The installed CLI needs no companion worker, PATH lookup, or executable extraction. bazel_agent bazel build -c opt //projects/anki_as_code produces an optimized executable with final symbol and debug information stripping. It uses the host Linux runtime libraries, including OpenSSL 3.

server shows the available server operations. server run forwards arguments to the linked Rust CLI, which owns native subcommands and their help. server serve invokes App.ServerServe, which delegates to App.ServerRun with serve prepended. Cobra forwards arguments without interpreting native flags:

anki_as_code server run --help
anki_as_code server serve --help
anki_as_code server serve --transport tcp --listen 127.0.0.1:50051
anki_as_code server serve --transport unix --listen ./anki.sock

Stdio is the default and reserves stdout for gRPC. TCP and Unix listeners use plaintext gRPC and require an explicit address. The child process keeps native failures and shutdown separate from the application workflow.

api <service> <method> constructs its command tree from the compiled Go protobuf descriptors for all 25 pinned Anki schemas. Bazel automatically generates the registration imports into internal/rpc from the pinned descriptor set using the project-local tools/generate_anki_schemas generator; no separate generation step or runtime schema files are needed. Service/method names use kebab-case, omit the Service suffix and retain backend- prefixes. Implicit backend methods are included. Help lists request fields and message types; no proto files or server discovery are needed.

anki_as_code api tags all-tags --collection ./collection.colpkg
anki_as_code api notes get-note --collection ./collection.anki2 \
  --input request.toml --input-format toml --output-format json
anki_as_code api notes get-note --backend unix:///path/to/anki.sock \
  --input request.json

Exactly one of --collection and --backend is required. Offline access starts the same executable with server serve and owns the collection lifetime. --backend accepts a TCP host:port, tcp://host:port, unix:///absolute/path or an absolute Unix socket path. It uses the server’s current collection and closes only the client connection. Explicit open/close/import RPCs require connected access. Unix URI paths can be relative, such as unix://anki.sock. App resolves methods, validates payloads and owns remote client connections directly; collection.Store manages only offline collection scopes.

Input defaults to stdin (--input -); JSON is the default input and output encoding. An empty request body is accepted for empty request messages. --timeout bounds input reading, startup and the request, defaulting to 30 seconds. Responses use stdout after cleanup succeeds; request, publication and cleanup errors use stderr and a nonzero exit status. Native error details are preserved.

Offline archive write-back is enabled by default. --write-back enables it and --no-write-back disables it; the last occurrence wins. Explicit boolean values such as --write-back=false are also accepted. Disabling write-back skips automatic .colpkg publication; native RPCs keep their normal effects. .anki2 mutations always commit directly. Requests are not transactions: earlier committed changes can persist even when a later RPC fails.

Export a full .colpkg from Anki, then close Anki and other collection writers. Use a fresh text directory so stale declarations from earlier exports are not included. Export configs and their native bindings together:

bazel_agent bazel run //projects/anki_as_code -- col export \
  --collection /absolute/path/collection.colpkg --output /absolute/path/text \
  --state-output /absolute/path/state.anki.toml
bazel_agent bazel run //projects/anki_as_code -- col state update \
  --collection /absolute/path/collection.colpkg /absolute/path/state.anki.toml
bazel_agent bazel run //projects/anki_as_code -- config dump \
  --text /absolute/path/text
# Edit the TOML files before planning and applying.
bazel_agent bazel run //projects/anki_as_code -- col plan \
  --collection /absolute/path/collection.colpkg --text /absolute/path/text
bazel_agent bazel run //projects/anki_as_code -- col apply \
  --collection /absolute/path/collection.colpkg --text /absolute/path/text
# Alternatively, build a separate archive instead of applying in place.
bazel_agent bazel run //projects/anki_as_code -- col build \
  --base /absolute/path/collection.colpkg --text /absolute/path/text \
  --output /absolute/path/rebuilt.colpkg

The export leaves collection content and its stored state unchanged; source archives may be repackaged. The optional state file contains version-1 TOML bindings for every exported deck, note and note type, including field/template identities and referenced scheduling preset aliases. It uses the exact generated filenames, including collision suffixes and names retained from the selected state namespace. col state update installs those bindings into the same collection before you edit configs. This preserves existing object identities and review progress when you later apply changes. Use the same --state-key for export, state update, plan, apply and build if selecting a custom namespace.

After editing, inspect col plan, then use col apply to update the supplied collection or col build to write a separate archive. After apply, import the updated archive into Anki; after build, import rebuilt.colpkg. Collection-backed bindings travel with the archive.

Omit --state-output for config-only export. Use col state import for selective manual bindings. Generated state belongs to the collection it was exported from; do not install it into an unrelated collection. State update merges bindings and retains omitted entries; col state replace intentionally removes omitted bindings. For an already managed collection, review exported state before installing it, especially if paths have changed.

--state-output names a TOML file, regardless of its extension. Current-user ~ paths are supported. The file may live outside the text directory or inside it under an unrelated name such as state.anki.toml. Export rejects source aliases, config declaration filenames and directories needed by exported configs. State output is atomically replaced after config export succeeds. Filesystem failures may leave partial configs; a failed config export retains the previous state output. The config tree and state file are not published as one filesystem transaction.

Use absolute paths with bazel run, which can start outside the checkout. Current-user ~ and ~/... paths are supported. --text accepts a collection root file or its directory. config dump defaults to JSON; --format toml is also available. The CLI starts its linked server through its own executable path. No Python is required.

config export [FILE] --output DIRECTORY writes a serialized CollectionConfigSet as the fixed TOML hierarchy. Input defaults to JSON; --format toml accepts a TOML-encoded config set. Omit FILE or use - to read stdin. The conf alias works for both dump and export. These commands operate without opening Anki.

anki_as_code config dump --text ./configs > configs.json
anki_as_code config export configs.json --output ./copy
anki_as_code config dump --text ./configs | anki_as_code config export --output ./copy

The caller supplies complete configs with valid, unique collection-relative paths. Schema decoding happens before writes; collection semantics and path validation remain the caller’s responsibility. Export overwrites declared files and retains unrelated entries. Filesystem failures can leave partial output; callers can export to a temporary directory when they need staged publication. Status goes to stderr and stdout stays empty.

App.ConfigExport(ctx, output, configs) exposes the same writer for Go callers through config.Store.Export, without changing the supplied protobuf object.

State commands accept an existing offline .anki2 database or .colpkg archive through --collection. Commands call App’s typed state workflows. App borrows one prepared connection from collection.Store, which reserves the source and constructs the native worker and collection backends. Collection cleanup finishes before transport cleanup and source reservation release. State stores borrow the connection and own no native lifetime or files.

Databases are opened directly and committed writes persist in place, including when a later operation fails. Packages are restored into a temporary directory and written back during cleanup through Anki’s atomic package API, including media. Publication runs independently of request outcomes and may repackage unchanged content. Normal cleanup removes restored files; publication failures or uncertain native completion follow the backend library’s retention/error contract.

Missing files and non-regular inputs fail before startup. Anki validates package contents during restore. Cleanup uses a bounded context independent of command cancellation, and operation and cleanup errors are preserved. Keep Anki and other writers closed during these operations. Collection export and reconciliation use the same native workflow.

anki_as_code col state dump --collection /path/to/collection.anki2 > state.anki.toml
anki_as_code col state import --collection /path/to/collection.anki2 --text /path/to/configs \
  decks/Default/deck.anki.toml=1 notes/example.note.anki.toml=123
anki_as_code col state update --collection /path/to/collection.anki2 state.anki.toml
anki_as_code col state replace --collection /path/to/collection.anki2 state.anki.toml

Dump returns stored bindings without writes or discovery. An absent namespace returns empty version-1 state. TOML is the default; --format json selects JSON. Update and replace read FILE or stdin when omitted/-. Status and errors use stderr; dump uses stdout.

Import accepts multiple PATH=ID arguments, resolves declared config paths before interpreting native identifiers, checks the requested existing objects and saves once after the complete batch succeeds. IDs remain strings at the CLI/Go API boundary; Anki currently requires positive int64 IDs. Note-type imports include native field/template bindings. Existing scheduling presets use presets/<alias> addresses. Import does not edit config files or native objects.

Update merges external version-1 state: omitted map keys remain, supplied keys replace their complete entry, including note-type member maps. Replace installs the whole object and removes omitted bindings. It can repair invalid saved state; invalid replacement input and native read failures still fail before writing. Validation rejects conflicting path/native ownership before writes. Empty updates and identical operations perform no state write. Native notes, cards, scheduling, history, presets and media remain owned by Anki.

Missing or unknown state subcommands fail with nonzero status and stderr output. Explicit col state --help succeeds.

--state-key KEY selects a namespace; the default is anki_as_code/state/v1. Only that key is written. Callers coordinate concurrent writes to the same key. State uses separate typed maps under State.Resources:

version = "1"
[resources.decks."decks/Default/deck.anki.toml"]
id = "1"
[resources.notes."notes/example.note.anki.toml"]
id = "123"
[resources.note_types."note_types/Basic.notetype.anki.toml"]
id = "456"
[resources.note_types."note_types/Basic.notetype.anki.toml".fields.Front]
id = "789"
[resources.presets.Default]
id = "1"

api/ankiascodeapi provides ankiascodeapi.App, the shared interface for configuration, collection, state and server workflows. pkg/ankiascode provides the concrete ankiascode.App. Its zero value supports configuration operations and borrowed connections. Path sources require explicit worker configuration; hosting the server requires an injected ServerRunner. ankiascode.New(ankiascode.Options{BackendBinary: path, BackendArguments: args}) configures an explicit worker executable and arguments. The CLI supplies its own executable and []string{"server", "serve"}. Operations follow the CLI namespaces: ConfigDump, ConfigExport, ColExport, ColPlan, ColApply, ColBuild, and ColStateDump, ColStateImport, ColStateUpdate, ColStateReplace, ServerRun and ServerServe. Each collection operation accepts an ankiascodeapi.CollectionSource from api/ankiascodeapi: a path described by CollectionPath(path) or an already-open connection described by CollectionConnection(connection). Exactly one alternative must be present. Constructors perform no I/O. ColBuild continues accepting a base archive path because it stages and opens an independent copy.

internal/cli owns the complete Cobra tree, flags, binding syntax, formats and streams. Every operation, including server run and server serve, goes through ankiascodeapi.App. The interface uses shared source types, strings, protobuf messages and standard-library types. Commands wrap collection path flags without opening resources. App owns server delegation and composes collection/configuration workflows; the lower-level packages retain their domain and lifecycle responsibilities. CLI does not host native code or construct App.

cmd/anki_as_code constructs App and passes it to cli.New. It injects the linked ankiserver.Run adapter through Options.ServerRunner and supplies process signal handling. App.ServerRun checks startup cancellation, builds the native argument vector and invokes that adapter. Native serving owns the process until return or termination; its context controls entry only. App does not link Rust/cgo or change process-global signals. Missing runner configuration fails before native hosting. Isolated command tests supply one fake without constructing App or starting Anki. Commands pass namespaces explicitly, and App retains no command configuration.

var application ankiascodeapi.App = ankiascode.New(ankiascode.Options{BackendBinary: serverPath, BackendArguments: []string{"serve"}})
source := ankiascodeapi.CollectionPath(absoluteCollectionPath)
// ConfigDump(ctx, path, format) works without a native backend.
value, err := application.ColStateDump(ctx, source, key)
err = application.ColStateImport(ctx, source, absoluteConfigPath, key, bindings)
err = application.ColStateUpdate(ctx, source, key, external)
err = application.ColStateReplace(ctx, source, key, replacement)

App’s path-based operations return after cleanup. Borrowed connections remain owned by their caller, including after failure or cancellation. Operations read fresh collection data and neither close the borrowed connection nor publish a package. Callers coordinate access and decide when to save and close; direct database writes persist immediately and multiple calls are not a transaction. One App can alternate between several open collections:

first := ankiascodeapi.CollectionConnection(firstConnection)
second := ankiascodeapi.CollectionConnection(secondConnection)
err := application.ColStateUpdate(ctx, first, key, external)
report, err := application.ColPlan(ctx, first, absoluteConfigPath, key)
other, err := application.ColStateDump(ctx, second, key)

The protobuf contract lives in api/ankiascodepb, with Go package ankiascodepb and protobuf namespace anki_as_code. Message names and fields retain the existing config and state formats; Go imports and protobuf fully qualified type names use the renamed API.

ColExport(ctx, source, output, stateOutput, stateKey) accepts an empty stateOutput for config-only export or a TOML file path for snapshot bindings. For a borrowed connection, its owner must keep both outputs distinct from native collection files: a connection source carries no filename for alias checks. Config/state output conflict checks still apply.

internal/collection.Store reserves existing sources and owns enabled archive publication. Construct it with explicit process options before collection access. WithCollection injects a prepared grpc.ClientConnInterface into its callback. Construct the services you need on that connection and reuse local instances for several operations.

collection.New(collection.Options{Backend: ankiclient.BackendSTDOptions{Binary: path, Arguments: args}}) configures the worker. No executable or server arguments are discovered by default; missing configuration fails before opening a collection. Callers supply their server executable and runtime inputs. Each scope constructs a fresh stdin/stdout worker and collection backend. It closes native storage before stopping the worker. Collection publication and close have a ten-minute default budget, configurable with Options.CollectionCloseTimeout; transport cleanup has a separate five-second budget independent of callback cancellation; source reservations outlive cleanup.

store := collection.New(collection.Options{Backend: ankiclient.BackendSTDOptions{Binary: serverPath, Arguments: []string{"serve"}}})
err := store.WithCollection(ctx, collection.CollectionOptions{Path: path, WriteBack: true}, func(connection grpc.ClientConnInterface) (bool, error) {
    resources := resource.New(connection)
    states := state.New(connection, key)
    exporter := export.New(resources, states)
    if err := exporter.Export(ctx, directory, ""); err != nil {
        return false, fmt.Errorf("export configs: %w", err)
    }
    changed, err := states.Replace(ctx, replacement)
    if err != nil {
        return false, fmt.Errorf("replace bindings: %w", err)
    }
    return changed, nil
})

Callbacks finish all work sequentially before returning. Retained connections reject calls after cleanup. Resource/state stores and exporters borrow the connection; each operation reads fresh data. A Store or App must not be copied after use. Duplicate canonical paths and file aliases are rejected within one Store; callers coordinate access across different stores and external writers.

CollectionOptions selects the source path and WriteBack policy. Enabled write-back publishes the source archive during cleanup independently of callback results, errors and cancellation. Application workflows explicitly enable it; API flags select it. Database writes persist immediately, including before later errors; the scope is not a transaction. To export another archive destination, use Anki’s ExportCollectionPackage with the injected connection as the final operation and disable WriteBack when source publication is unwanted. Native export consumes the open collection; backend cleanup handles it.

App.APICall(ctx, ankiascodeapi.APIRequest{...}) exposes the same generic operation without per-method wrappers. Supply a fully qualified gRPC Method, Input bytes and JSON/TOML encodings. Collection accepts the shared path or borrowed-connection source; Backend selects an app-owned connection to a running server. Exactly one is required. WriteBack defaults to false for Go callers; the CLI explicitly selects true. Borrowed native connections retain caller-owned cleanup and publication. Request validation precedes native startup.

State store operations and Anki storageState store operations and Anki storage

internal/state borrows a prepared connection and owns no process, collection lifecycle or files. The selected namespace defaults when the key is empty:

store := state.New(connection, "")
value, err := store.Dump(ctx)
changed, err := store.Import(ctx, configs, map[string]string{
    "notes/example.note.anki.toml": "123",
})
changed, err = store.Update(ctx, external)
changed, err = store.Replace(ctx, replacement)

Dump, Update and Replace exchange *ankiascodepb.State. Import accepts a parsed *ankiascodepb.CollectionConfigSet and path/ID strings. Multiple calls reuse the same prepared connection. The changed flag reports whether state was written. State.Resources groups typed deck, note, note-type and preset maps; note types own field/template maps.

state.Export(configs, snapshot, identities) generates version-1 bindings from projected configs, their path-to-native-ID map and the same native snapshot. State owns construction and validation of resource and member bindings, including scheduling preset aliases. This pure operation performs no backend calls and installs no state. Collection export owns config paths and file output.

For path sources, App delegates native access to collection.Store.WithCollection. The store reserves the source and constructs BackendSTD and BackendCollection, using only the explicitly configured executable and arguments. BackendCollection restores packages into temporary storage or opens databases directly. Callbacks receive the prepared connection and construct their own services. Store closes the collection before stopping the worker, including after callback errors, cancellation and panic unwinding.

BackendCollection owns readiness, native import/open/close and restore cleanup. Its failure contract can retain restore files when native completion is uncertain, reporting their path. The CLI and App add no restore owner or lifecycle state machine.

Store reserves each source before startup and retains that reservation through cleanup. When WriteBack is enabled, BackendCollection publishes its source archive through Anki independently of callback outcomes. Anki writes and atomically replaces that archive. Database operations persist in place. Build separately copies its base to a temporary directory beside the destination, applies to that copy and atomically replaces the destination after success. Failed builds remove staging and leave the destination untouched. Callers own exclusive access to the base and destination. State, export and reconciliation borrow prepared services without owning lifetime.

Export writes configuration TOML without changing the source collection. --state-output optionally writes matching snapshot bindings for onboarding. Existing stored bindings retain note and note-type filenames on re-export. New note types receive unused filenames with numeric suffixes when their names collide with tracked paths, including case-only differences and fallback names. Without bindings, native edits can change content-derived filenames.

Export selects a note’s directory from its first regular card. Card generation or changed destinations can therefore change an exported path, including when Anki chooses a deck for a new root note. When adopting these new paths, declare [[moved]] entries from their stored paths before applying. Export does not rewrite bindings. Applying the same root-note configs again preserves native identity and converges; Anki owns their initial deck selection.

Follow onboarding to bind the whole export before the first reconciliation, or use col state import for selective bindings. New configs without bindings describe new objects. State dump exports stored bindings separately; it does not discover bindings for an untracked config tree:

bazel_agent bazel run //projects/anki_as_code -- col state dump \
  --collection /absolute/path/collection.colpkg > /absolute/path/state.anki.toml

Export writes declared files directly through config.Store.Export and does not reload generated files. Other entries remain untouched, including old configs and state files other than an explicit --state-output destination. The destination must not contain the source collection. Filesystem errors may leave partial output.

Use a fresh destination for a clean snapshot. For directory cleanup or synchronization, export to a temporary directory and use rsync or another external tool; those policies belong to the caller.

To rename or move a resource without replacing it, move its file/directory and add a root [[moved]] pair. Directory moves include descendant notes/decks; type moves include their members. Fields/templates use addresses such as note_types/Basic.notetype.anki.toml#fields/Front. Update readable references in the same edit. Moves require independent, nonoverlapping endpoints, reject occupied destinations, and are idempotent when retained. The old source must no longer be declared. Remove a completed move before reusing its old path.

  • Notes: add/remove tracked notes; edit exact named fields and tags shared by their generated cards. Only tracked notes missing from configs are removed.
  • Regular-deck assignments: move generated cards using note defaults and template/cloze ordinals. Card entries assign decks and do not declare existence. Before deleting a deck containing retained cards, declare a surviving destination for them. An omitted assignment keeps the card and its existing deck.
  • Decks: create, rename/move, remove, and edit normal or filtered configuration. Titles derive from the fixed hierarchy. A deck must be empty in Anki before conversion between normal and filtered kinds. Native APIs must support the requested removal; required native objects cannot silently become untracked.
  • Note types: create, rename, remove, and edit ordered fields, templates, CSS, browser fonts, and upstream presentation settings. Explicit member moves preserve field/template identities. Edit affected named note fields together. Existing notes cannot switch to another native note type through this CLI.

These are excluded from editable desired state:

  • Resident filtered cards: membership, home decks, and temporary scheduling belong to Anki. Their assignments are omitted. Empty the filtered deck before removing referenced resources or changing a resident card’s template structure.
  • Scheduling presets: referenced by readable names; never created, deleted, or edited. The CLI calls no preset-writing API.
  • Existing card scheduling/state and review history: preserved in the database to retain study progress. Anki initializes cards it generates for new notes/templates.
  • Media payloads: preserved through Anki’s native package APIs. Field references are editable; media creation/deletion is outside the workflow.
  • Collection/UI/sync settings and native metadata: owned by Anki and omitted from text. API operations update their normal bookkeeping as needed.
  • Untracked objects: preserved during apply. Import them before edits that would destroy their references, such as deleting a deck with untracked cards, renaming a parent with untracked children, or changing shared field/card structure.

Plan reads an API snapshot, resolves config references and moves, checks owned relationships, and compares requested resources in memory. It performs no native mutations, writes no bindings and creates no database copy. It reports paths, resource changes and known card deck assignments. card_generation_deferred indicates that Anki determines generated-card effects during apply; the planner does not claim exact creation/removal counts for those effects.

Anki performs final template validation, normalization and card generation during apply. Planning can therefore accept a template that apply rejects. Source values that Anki normalizes can remain different from stored values in subsequent plans; accepted values are never written back into TOML.

Database apply updates the supplied collection directly. Anki commits each native operation, so later errors can leave earlier operations committed. Archive apply uses Anki’s atomic package export during cleanup. Earlier committed changes can persist after later request failures; read operations may repackage unchanged content. Build requires a distinct archive output and stages its copy before Apply, publishing the completed archive atomically after success. Keep other writers closed while using a collection; the CLI does not detect concurrent archive replacement.

Collection export writes its declared config files in place. It does not traverse, clean or replace the destination directory. Other entries remain untouched, and filesystem errors may leave partial output. Callers can export to a temporary directory and synchronize it externally when required. Converged database apply leaves source bytes unchanged. Note-type comparison ignores runtime ordinal hints and unmanaged metadata while retaining explicit field/template identity changes. New notes use Anki’s batch creation API. Export neither writes source state nor produces a state file. Failed native reads or projection leave existing output unchanged.

collection.anki.toml
note_types/
  Basic.notetype.anki.toml
notes/
  unattached.note.anki.toml
decks/
  Languages/
    deck.anki.toml
    notes/
      introduction.note.anki.toml
    decks/
      French/
        deck.anki.toml
        notes/
          greeting.note.anki.toml

The root contains version, currently 1. Optional moves describe file, directory, or nested definition address changes for reconciliation:

version = "1"
[[moved]]
from = 'decks/Old'
to = 'decks/Languages'

decks/Languages/decks/French/ declares Languages::French. Every deck directory requires deck.anki.toml. Titles come from the hierarchy and are absent from markers. A normal deck references an existing scheduling preset by readable name:

preset = 'Default'
[normal]
description = 'Language lessons'

Notes reference note types by configuration path and contain exact named fields:

note_type = 'note_types/Basic.notetype.anki.toml'
[fields]
Front = 'Bonjour'
Back = 'Hello'
[[cards]]
ordinal = "0"

An omitted card deck inherits its declaring deck’s marker path. Explicit card and template overrides use paths such as decks/Languages/deck.anki.toml. Note types declare names, upstream configuration, ordered fields and templates. sort_field selects a field by name; template target_deck references a deck path. Array order determines field/template positions.

Paths identify resources. Editable configs contain no top-level Anki IDs or note GUIDs. A note at a new path declares a new resource; identity-preserving moves belong in the root’s moved list. Explicit state operations install bindings inside the collection; export writes configs only. The identity generation command has been removed.

The loader lists immediate files in notes/ and note_types/, descending only through child decks/. Other files and deeper note directories are ignored. Missing resource directories are empty sets. Empty markers are parseable; business logic determines whether they are usable. Symlinks, non-directory resource roots, and missing deck markers fail.

The format is unreleased and stays version 1 while the schema evolves. Only the current schema is supported. Normal/filtered settings and note-type presentation reuse Anki messages. Native-only fields in reused messages are omitted by collection export and rejected by reconciliation; pure dump/export retains supplied protobuf values without semantic checks.

Load, Dump, and Export configuration processesLoad, Dump, and Export configuration processes

These operations work with configuration files and protobuf objects without opening Anki. Load checks syntax, schema, version, and filesystem layout; callers own collection semantics. Dump calls Load and serializes the complete parsed set. Export can write a caller-supplied object directly without loading it first. Read, encoding, and filesystem failures end the operation with an error. Export may leave partial output; it does not validate relationships or clean up files.

Configuration modelConfiguration model

The class diagram shows root and resource configuration messages. References use paths; card and template deck references target normal decks. Each note stores shared field content and tags, while note types define ordered fields, templates, and presentation. The root marker contains the version and explicit moves. Attached notes identify each file’s location in the fixed hierarchy. In Load, each file is decoded as it is read, and deck titles and omitted card deck paths are derived inside the deck loop. Dump selects JSON or TOML encoding for the complete configuration set.

TOML decodes to generic values, then JSON, then protobuf using ProtoJSON. Unknown keys and incompatible values fail. Unquoted TOML dates/times fail rather than silently becoming strings; quote dates used as note text. Output converts ProtoJSON directly to TOML, preserving optional presence and exact text values. 64-bit values use quoted decimal strings, including version = "1".

config.New(root) returns a *config.Store bound to a configuration path without accessing the filesystem. Use a directory for writing; reads also accept a root config file. The store exposes:

  • Load() (*ankiascodepb.CollectionConfigSet, error) parses the hierarchy.
  • Dump(format string) ([]byte, error) loads and encodes JSON or TOML.
  • Export(configs *ankiascodepb.CollectionConfigSet) error writes the root marker and supplied path/config pairs as TOML files beneath its directory.
store := config.New(absoluteDirectory)
configs, err := store.Load()
data, err := store.Dump("json")
err = store.Export(configs)

Stores retain no parsed messages or open files. Each Load reads fresh values; callers own filesystem coordination and the returned messages. config.Version supplies the supported schema version to collection exporters.

Export writes directly, preserves input messages, overwrites declared files, and leaves unrelated/stale files alone. Callers own valid, unique paths, layout, validation, staging, cleanup, and publication. Export does not load or normalize its output; failures may leave partial files. Consumers use the store; the layout package remains an implementation API with restricted Bazel visibility.

config/layout owns the fixed hierarchy, discovery, file I/O, and direct file export. internal/codec converts TOML/JSON through protobuf without filesystem access. Config layout, config dump, state CLI commands, and collection export reuse its format dispatch; TOML/JSON helpers are private. Dependencies flow from config to layout/codec and from layout to codec. State stores have no serialization dependency. Collection relationship validation and native operations remain outside them.

Anki as code runtime architectureAnki as code runtime architecture

The outer box shows the executable’s components: the CLI, App, and the linked Rust server library. The CLI invokes App, which reads and writes text Configs. Run (C ABI) invokes the library through the injected server runner. Path-based workflows launch another instance of anki_as_code as a server subprocess and use gRPC over stdio to communicate with its Server. The Server delegates storage operations to the Anki API. Both server variants access Anki storage, which holds native resources and the application’s persisted state.

The external-server gRPC edge is used by api --backend with an explicit TCP or Unix address. App owns only its client connection. Go callers can also prepare external connections through ankiclient.BackendGRPC and pass them to App through ankiascodeapi.CollectionConnection.

The project keeps one Go module with focused packages. Configs and state are protobuf contracts. Runtime resolution models stay private to internal/plan; packages expose only operations used by their consumers.

Anki CLI package dependenciesAnki CLI package dependencies

Each package’s doc.go describes its responsibilities and boundaries; this diagram shows how the packages compose.

Dotted edges show calls through injected contracts. Solid edges show component dependencies.

Package Responsibility
cmd/anki_as_code App construction, CLI invocation and process signals
internal/cli Cobra commands, application dispatch and streams
internal/collection Source reservations and archive publication
api/ankiascodepb Generated config, plan, and persisted-state contracts
api/ankiascodeapi Shared application interface and collection source contracts
pkg/ankiascode Application workflows and service composition
internal/export Native-to-config projection and direct file output
internal/plan Pure resolution, comparison, ownership and prepared operations
internal/reconcile Execute protobuf plans, bind native IDs and persist state
internal/rebuild Apply to a staged archive copy and publish it atomically
internal/resource Native generated clients and fresh resource snapshots
internal/config Root-bound configuration Store for Load, Dump, and Export
internal/config/layout Fixed hierarchy, discovery, file I/O, and direct export
internal/rpc Compiled upstream descriptor catalog and protobuf RPC execution
internal/codec Filesystem-independent protobuf/TOML/JSON conversion
internal/state Stored-state dump, import, update, and replacement

The command entry point injects App into internal/cli through ankiascodeapi.App, checking compatibility during compilation. Commands use the shared interface without importing the implementation. Shared API types do not depend on native backend ownership. App obtains a prepared connection from the supplied source and constructs its services locally. Path sources use collection.Store; borrowed sources retain caller-owned lifetime. export.New(resources, states) constructs an Exporter using caller-provided resource and state stores. Its Export(ctx, output) method owns native-to-config projection, filenames and direct config output. State operations remain separate. Export has no dependency on reconciliation.

plan.Build(configs, snapshot, stored) constructs prepared protobuf operations without I/O. reconcile.New(resources, states) constructs a Reconciler whose Apply(ctx, compiled) method executes them and returns whether native data or bindings changed. App shares config loading, capture and plan preparation between plan and apply within one collection scope. Planning owns reference resolution, comparison and ownership; execution owns native calls and returned identities.

Config and codec have no Anki runtime dependency. State owns stored path bindings, not lifecycle or serialization. App uses the Go backends in projects/anki_grpc and Anki’s collection/package services; Resource owns generated resource clients and fresh native snapshots. The executor borrows resource/state stores and owns no process or filesystem resources. There is no archive facade or handwritten ZIP/Zstandard handling. Anki owns storage compatibility, normalization, structural migrations, field caches, and card generation. No HTML cache rebuilding or SQLite driver is implemented in Go. The application does not force Check Database after import; normal Anki API updates maintain their caches.

Planning orchestration and pure plan constructionPlanning orchestration and pure plan construction

plan.Build(configs, snapshot, stored) returns an executable protobuf CollectionPlan from caller-supplied configs, a resource snapshot and stored bindings. It performs no I/O and leaves all inputs unchanged. Callers capture fresh inputs under exclusive offline access to the same collection and namespace. Backend lifetime belongs to the caller; planning can run with the backend open or closed.

The plan separates expected_state from proposed_bindings and contains a change report, prepared deck/type/note operations, name releases, tracked deletions and card destinations. New objects have zero native IDs; prepared note-type and template-deck references use configuration paths. Resource comparison produces operations and report entries together. Converged plans have no native operations. Card destinations are included only for known changes or relevant native generation. Planning indexes native protobufs directly and resolves desired configs into the prepared protobufs used for comparison and execution. Returned payloads are independent of supplied inputs; path/ID indexes and ownership checks stay private to internal/plan. Member moves rename fields or templates within one note type; cross-type identity transfers are rejected. Stable native member IDs are authoritative. Without IDs, matching uses original stored names, including before explicit renames; stale ordinals cannot claim another current member. Ambiguous bindings fail before a plan is returned. Untracked resources and resident filtered cards stay unmanaged, including deck targets referenced by untracked templates. All cloze card ordinals share template zero; resident cards block template replacement or removal, while explicit template moves that preserve identity remain allowed.

Anki owns native validation, normalization, structural migrations and card generation. The report compares current card destinations and cards removed with deleted notes; template-driven additions, removals and migrations remain deferred through card_generation_deferred. Prepared operations do not simulate those native effects. The CLI and App’s ColPlan return the report; Go services pass the complete plan to reconcile.New(resources, states).Apply(ctx, compiled).

The executor checks expected stored state before writes, executes prepared operations, resolves new native IDs and persists bindings. It never loads configs, captures a resource snapshot, matches members or recomputes the plan. Native metadata and newly generated cards are read only as needed to execute it. A private applier reads the supplied plan unchanged, clones the proposed bindings, and copies only note-type requests whose native identities or presentation need updating. Reports, expected state and note bodies are not cloned. Callers retain exclusive access and own freshness beyond stored-state checks.

compiled, err := plan.Build(configs, snapshot, stored)
changed, err := reconcile.New(resources, states).Apply(ctx, compiled)

internal/rebuild stages a separate collection archive using an injected apply operation:

builder := rebuild.New(apply)
err := builder.Build(ctx, baseArchive, outputArchive)

The non-nil callback receives a private .colpkg path and must finish all native work and close its session before returning. Builder knows nothing about configs, Anki clients or reconciliation. Callers own home-path expansion and exclusive source/destination access; the destination parent must already exist.

Builder checks the regular source file and rejects source/destination aliases, copies into a private directory beside the destination, then publishes the completed archive with an atomic rename. Apply errors, cancellation observed before publication and publication failures leave the original and existing destination intact. Staging is removed on return, including panic unwinding; cleanup errors are retained. Cancellation preserves both the context error and its custom cause for errors.Is. Atomic publication does not guarantee power-loss durability. The App callback delegates to ColApply.

Run bazel_agent bazel test //projects/anki_as_code/internal/rebuild:rebuild_test. The native E2E changes real Anki state in the staged archive and emits original, changed and unchanged .colpkg files plus a decoded JSON state object.

internal/resource shares generated native clients and complete snapshots on a caller-owned prepared connection:

resources := resource.New(connection)
snapshot, err := resources.Snapshot(ctx)
note, err := resources.Notes.GetNote(ctx, &notes.NoteId{Nid: noteID})

Store exposes the generated deck, note-type, note, card, search, preset and rendering clients without forwarding wrappers. Snapshot returns upstream protobuf objects, including unmanaged resources and resident filtered cards, plus preset names. Decks are ordered by title; note types, notes and cards by native ID. Each call reads fresh values and returns caller-owned results. There is no cache or atomic snapshot guarantee; callers provide exclusive offline access.

The resource store owns no backend lifecycle, state bindings, configs, projection, planning or mutation order. Export and reconciliation retain those policies. No SQL or duplicate storage logic is involved.

Export data flowExport data flow

internal/export borrows resource and state stores for the same prepared collection:

resources := resource.New(connection)
states := state.New(connection, key)
exporter := export.New(resources, states)
err := exporter.Export(ctx, absoluteOutputDirectory, absoluteStateFile)

Stored bindings retain filenames and preset aliases. Export(ctx, directory, stateFile) writes configs and optional bindings from the same snapshot as TOML. An empty state destination selects config-only behavior. Export never installs state; state operations remain separate. The destination must not contain the source collection.

New note filenames use Anki’s HtmlToTextLine result for the configured sort field. Go only sanitizes that text into a bounded Unicode filename. Bound names are reused from state; filename conversion never changes stored note fields.

Export owns config projection and readable filenames and delegates file output to config.Store.Export. It overwrites declared configs in place and leaves other entries untouched, including stale configs and caller-owned state files. Filesystem errors may leave partial output. For cleanup or publication policies, export to a temporary directory and synchronize it externally, for example with rsync. The caller also owns exclusive offline access, backend startup, collection preparation and shutdown.

Export and reconciliation share resource.Store for generated clients and fresh native snapshots; their projection and policy remain separate.

The reusable Go backend and Rust server belong to projects/anki_grpc. The Go package owns the server process and exposes a managed gRPC connection. Callers use Anki’s generated service clients for typed methods. Anki owns collection validation, note updates, card generation, and persistence; this CLI owns TOML and reconciliation.

Direct storage editing has the simplest integration: an application edits SQLite and protobuf itself, taking responsibility for Anki’s data invariants and business logic. The API-based approaches are Python with Anki’s official SDK, Rust with Anki’s Rust API, and another language with a translation layer around the Rust API. The two Rust API approaches require building Anki from source. A translation layer can be a C ABI or a gRPC sidecar; it does not remove that build requirement.

This project uses a translation layer: the Go CLI calls the Rust server in projects/anki_grpc, which forwards operations to Anki’s Rust API. Go owns the server process and its failures.

Anki backend integration approachesAnki backend integration approaches

The maintained Mermaid source is rendered by the :backend_approaches Bazel target and published with the project documentation.

bazel_agent bazel build //projects/anki_as_code
bazel_agent bazel test //projects/anki_as_code/pkg/ankiascode:ankiascode_test \
  //projects/anki_as_code/internal/export:export_test \
  //projects/anki_as_code/internal/config:store_test \
  //projects/anki_as_code/internal/cli:command_test \
  //projects/anki_as_code/cmd/anki_as_code:cli_workflow_test

Synthetic native E2E verifies reviewed-card/history/preset/media retention, filtered cards, field/template migrations, copied notes, config-only export and independent state operations, import/moves, untracked-object safety, read-only configs, convergence, rejected publication, large fields/archives, and Anki’s actual full-package round trip. CLI E2E verifies streams, flags, removed generation, and pure config behavior. Repeatable TOML, JSON, and collection artifacts are emitted through Bazel’s undeclared test outputs. Exact-candidate delivery receipts own validation status.

The independent exporter E2E uses a caller-managed native backend and collection. It checks exact Unicode/multiline fields, presentation, member bindings, stable bound/discovered paths, native filename text conversion, filtered-card exclusion, read-only state namespaces, untouched existing entries, cancellation and partial output after filesystem errors. It emits a complete text tree and a native .colpkg artifact. Run bazel_agent bazel test //projects/anki_as_code/internal/export:export_test.

1 - CLI reference

Export and reconcile Anki collections as TOML

Choose a command to see its usage, options, and complete nested help.

  • api — Invoke upstream Anki services using protobuf JSON or TOML
  • col — Inspect and manage Anki collections
  • config — Inspect and manipulate collection configuration files
  • help — Help about any command
  • server — Manage the native Anki server

1.1 - api

Invoke upstream Anki services using protobuf JSON or TOML
Invoke upstream Anki services using protobuf JSON or TOML

Usage:
  anki_as_code api [command]

Available Commands:
  ankidroid               anki.ankidroid.AnkidroidService
  backend-anki-hub        anki.ankihub.BackendAnkiHubService
  backend-ankidroid       anki.ankidroid.BackendAnkidroidService
  backend-ankiweb         anki.ankiweb.BackendAnkiwebService
  backend-card-rendering  anki.card_rendering.BackendCardRenderingService
  backend-cards           anki.cards.BackendCardsService
  backend-collection      anki.collection.BackendCollectionService
  backend-config          anki.config.BackendConfigService
  backend-deck-config     anki.deck_config.BackendDeckConfigService
  backend-decks           anki.decks.BackendDecksService
  backend-frontend        anki.frontend.BackendFrontendService
  backend-github          anki.github.BackendGithubService
  backend-i18n            anki.i18n.BackendI18nService
  backend-image-occlusion anki.image_occlusion.BackendImageOcclusionService
  backend-import-export   anki.import_export.BackendImportExportService
  backend-links           anki.links.BackendLinksService
  backend-media           anki.media.BackendMediaService
  backend-notes           anki.notes.BackendNotesService
  backend-notetypes       anki.notetypes.BackendNotetypesService
  backend-scheduler       anki.scheduler.BackendSchedulerService
  backend-search          anki.search.BackendSearchService
  backend-stats           anki.stats.BackendStatsService
  backend-sync            anki.sync.BackendSyncService
  backend-tags            anki.tags.BackendTagsService
  card-rendering          anki.card_rendering.CardRenderingService
  cards                   anki.cards.CardsService
  collection              anki.collection.CollectionService
  config                  anki.config.ConfigService
  deck-config             anki.deck_config.DeckConfigService
  decks                   anki.decks.DecksService
  frontend                anki.frontend.FrontendService
  i18n                    anki.i18n.I18nService
  image-occlusion         anki.image_occlusion.ImageOcclusionService
  import-export           anki.import_export.ImportExportService
  links                   anki.links.LinksService
  media                   anki.media.MediaService
  notes                   anki.notes.NotesService
  notetypes               anki.notetypes.NotetypesService
  scheduler               anki.scheduler.SchedulerService
  search                  anki.search.SearchService
  stats                   anki.stats.StatsService
  tags                    anki.tags.TagsService

Flags:
  -h, --help   help for api

Additional help topics:
  anki_as_code api anki-hub   anki.ankihub.AnkiHubService
  anki_as_code api ankiweb    anki.ankiweb.AnkiwebService
  anki_as_code api github     anki.github.GithubService
  anki_as_code api sync       anki.sync.SyncService

Use "anki_as_code api [command] --help" for more information about a command.

anki.ankihub.AnkiHubService

anki.ankidroid.AnkidroidService

Usage:
  anki_as_code api ankidroid [command]

Available Commands:
  flush-all-queries            /anki.ankidroid.AnkidroidService/FlushAllQueries
  flush-query                  /anki.ankidroid.AnkidroidService/FlushQuery
  get-active-sequence-numbers  /anki.ankidroid.AnkidroidService/GetActiveSequenceNumbers
  get-column-names-from-query  /anki.ankidroid.AnkidroidService/GetColumnNamesFromQuery
  get-next-result-page         /anki.ankidroid.AnkidroidService/GetNextResultPage
  insert-for-id                /anki.ankidroid.AnkidroidService/InsertForId
  run-db-command               /anki.ankidroid.AnkidroidService/RunDbCommand
  run-db-command-for-row-count /anki.ankidroid.AnkidroidService/RunDbCommandForRowCount
  run-db-command-proto         /anki.ankidroid.AnkidroidService/RunDbCommandProto

Flags:
  -h, --help   help for ankidroid

Use "anki_as_code api ankidroid [command] --help" for more information about a command.

/anki.ankidroid.AnkidroidService/FlushAllQueries

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api ankidroid flush-all-queries [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for flush-all-queries
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.AnkidroidService/FlushQuery

Request: anki.generic.Int32
Response: anki.generic.Empty

Request fields:
  val: optional sint32

Usage:
  anki_as_code api ankidroid flush-query [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for flush-query
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.AnkidroidService/GetActiveSequenceNumbers

Request: anki.generic.Empty
Response: anki.ankidroid.GetActiveSequenceNumbersResponse

Usage:
  anki_as_code api ankidroid get-active-sequence-numbers [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-active-sequence-numbers
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.AnkidroidService/GetColumnNamesFromQuery

Request: anki.generic.String
Response: anki.generic.StringList

Request fields:
  val: optional string

Usage:
  anki_as_code api ankidroid get-column-names-from-query [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-column-names-from-query
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki_as_code api ankidroid get-next-result-page

/anki.ankidroid.AnkidroidService/GetNextResultPage

Request: anki.ankidroid.GetNextResultPageRequest
Response: anki.ankidroid.DbResponse

Request fields:
  sequence: optional int32
  index: optional int64

Usage:
  anki_as_code api ankidroid get-next-result-page [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-next-result-page
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.AnkidroidService/InsertForId

Request: anki.generic.Json
Response: anki.generic.Int64

Request fields:
  json: optional bytes

Usage:
  anki_as_code api ankidroid insert-for-id [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for insert-for-id
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.AnkidroidService/RunDbCommand

Request: anki.generic.Json
Response: anki.generic.Json

Request fields:
  json: optional bytes

Usage:
  anki_as_code api ankidroid run-db-command [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for run-db-command
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.AnkidroidService/RunDbCommandForRowCount

Request: anki.generic.Json
Response: anki.generic.Int64

Request fields:
  json: optional bytes

Usage:
  anki_as_code api ankidroid run-db-command-for-row-count [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for run-db-command-for-row-count
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.AnkidroidService/RunDbCommandProto

Request: anki.generic.Json
Response: anki.ankidroid.DbResponse

Request fields:
  json: optional bytes

Usage:
  anki_as_code api ankidroid run-db-command-proto [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for run-db-command-proto
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.ankiweb.AnkiwebService

anki.ankihub.BackendAnkiHubService

Usage:
  anki_as_code api backend-anki-hub [command]

Available Commands:
  ankihub-login  /anki.ankihub.BackendAnkiHubService/AnkihubLogin
  ankihub-logout /anki.ankihub.BackendAnkiHubService/AnkihubLogout

Flags:
  -h, --help   help for backend-anki-hub

Use "anki_as_code api backend-anki-hub [command] --help" for more information about a command.

/anki.ankihub.BackendAnkiHubService/AnkihubLogin

Request: anki.ankihub.LoginRequest
Response: anki.ankihub.LoginResponse

Request fields:
  id: optional string
  password: optional string

Usage:
  anki_as_code api backend-anki-hub ankihub-login [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for ankihub-login
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankihub.BackendAnkiHubService/AnkihubLogout

Request: anki.ankihub.LogoutRequest
Response: anki.generic.Empty

Request fields:
  token: optional string

Usage:
  anki_as_code api backend-anki-hub ankihub-logout [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for ankihub-logout
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.ankidroid.BackendAnkidroidService

Usage:
  anki_as_code api backend-ankidroid [command]

Available Commands:
  debug-produce-error          /anki.ankidroid.BackendAnkidroidService/DebugProduceError
  flush-all-queries            /anki.ankidroid.BackendAnkidroidService/FlushAllQueries
  flush-query                  /anki.ankidroid.BackendAnkidroidService/FlushQuery
  get-active-sequence-numbers  /anki.ankidroid.BackendAnkidroidService/GetActiveSequenceNumbers
  get-column-names-from-query  /anki.ankidroid.BackendAnkidroidService/GetColumnNamesFromQuery
  get-next-result-page         /anki.ankidroid.BackendAnkidroidService/GetNextResultPage
  insert-for-id                /anki.ankidroid.BackendAnkidroidService/InsertForId
  local-minutes-west-legacy    /anki.ankidroid.BackendAnkidroidService/LocalMinutesWestLegacy
  run-db-command               /anki.ankidroid.BackendAnkidroidService/RunDbCommand
  run-db-command-for-row-count /anki.ankidroid.BackendAnkidroidService/RunDbCommandForRowCount
  run-db-command-proto         /anki.ankidroid.BackendAnkidroidService/RunDbCommandProto
  sched-timing-today-legacy    /anki.ankidroid.BackendAnkidroidService/SchedTimingTodayLegacy
  set-page-size                /anki.ankidroid.BackendAnkidroidService/SetPageSize

Flags:
  -h, --help   help for backend-ankidroid

Use "anki_as_code api backend-ankidroid [command] --help" for more information about a command.

/anki.ankidroid.BackendAnkidroidService/DebugProduceError

Request: anki.generic.String
Response: anki.generic.Empty

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-ankidroid debug-produce-error [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for debug-produce-error
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.BackendAnkidroidService/FlushAllQueries

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-ankidroid flush-all-queries [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for flush-all-queries
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.BackendAnkidroidService/FlushQuery

Request: anki.generic.Int32
Response: anki.generic.Empty

Request fields:
  val: optional sint32

Usage:
  anki_as_code api backend-ankidroid flush-query [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for flush-query
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.BackendAnkidroidService/GetActiveSequenceNumbers

Request: anki.generic.Empty
Response: anki.ankidroid.GetActiveSequenceNumbersResponse

Usage:
  anki_as_code api backend-ankidroid get-active-sequence-numbers [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-active-sequence-numbers
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.BackendAnkidroidService/GetColumnNamesFromQuery

Request: anki.generic.String
Response: anki.generic.StringList

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-ankidroid get-column-names-from-query [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-column-names-from-query
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki_as_code api backend-ankidroid get-next-result-page

/anki.ankidroid.BackendAnkidroidService/GetNextResultPage

Request: anki.ankidroid.GetNextResultPageRequest
Response: anki.ankidroid.DbResponse

Request fields:
  sequence: optional int32
  index: optional int64

Usage:
  anki_as_code api backend-ankidroid get-next-result-page [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-next-result-page
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.BackendAnkidroidService/InsertForId

Request: anki.generic.Json
Response: anki.generic.Int64

Request fields:
  json: optional bytes

Usage:
  anki_as_code api backend-ankidroid insert-for-id [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for insert-for-id
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.BackendAnkidroidService/LocalMinutesWestLegacy

Request: anki.generic.Int64
Response: anki.generic.Int32

Request fields:
  val: optional int64

Usage:
  anki_as_code api backend-ankidroid local-minutes-west-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for local-minutes-west-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.BackendAnkidroidService/RunDbCommand

Request: anki.generic.Json
Response: anki.generic.Json

Request fields:
  json: optional bytes

Usage:
  anki_as_code api backend-ankidroid run-db-command [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for run-db-command
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.BackendAnkidroidService/RunDbCommandForRowCount

Request: anki.generic.Json
Response: anki.generic.Int64

Request fields:
  json: optional bytes

Usage:
  anki_as_code api backend-ankidroid run-db-command-for-row-count [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for run-db-command-for-row-count
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.BackendAnkidroidService/RunDbCommandProto

Request: anki.generic.Json
Response: anki.ankidroid.DbResponse

Request fields:
  json: optional bytes

Usage:
  anki_as_code api backend-ankidroid run-db-command-proto [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for run-db-command-proto
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankidroid.BackendAnkidroidService/SchedTimingTodayLegacy

Request: anki.ankidroid.SchedTimingTodayLegacyRequest
Response: anki.scheduler.SchedTimingTodayResponse

Request fields:
  created_secs: optional int64
  created_mins_west: optional sint32
  now_secs: optional int64
  now_mins_west: optional sint32
  rollover_hour: optional sint32

Usage:
  anki_as_code api backend-ankidroid sched-timing-today-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sched-timing-today-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki_as_code api backend-ankidroid set-page-size

/anki.ankidroid.BackendAnkidroidService/SetPageSize

Request: anki.generic.Int64
Response: anki.generic.Empty

Request fields:
  val: optional int64

Usage:
  anki_as_code api backend-ankidroid set-page-size [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-page-size
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.ankiweb.BackendAnkiwebService

Usage:
  anki_as_code api backend-ankiweb [command]

Available Commands:
  check-for-update /anki.ankiweb.BackendAnkiwebService/CheckForUpdate
  get-addon-info   /anki.ankiweb.BackendAnkiwebService/GetAddonInfo

Flags:
  -h, --help   help for backend-ankiweb

Use "anki_as_code api backend-ankiweb [command] --help" for more information about a command.

/anki.ankiweb.BackendAnkiwebService/CheckForUpdate

Request: anki.ankiweb.CheckForUpdateRequest
Response: anki.ankiweb.CheckForUpdateResponse

Request fields:
  version: optional uint32
  buildhash: optional string
  os: optional string
  install_id: optional int64
  last_message_id: optional uint32

Usage:
  anki_as_code api backend-ankiweb check-for-update [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for check-for-update
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.ankiweb.BackendAnkiwebService/GetAddonInfo

Request: anki.ankiweb.GetAddonInfoRequest
Response: anki.ankiweb.GetAddonInfoResponse

Request fields:
  client_version: optional uint32
  addon_ids: repeated uint32

Usage:
  anki_as_code api backend-ankiweb get-addon-info [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-addon-info
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.card_rendering.BackendCardRenderingService

Usage:
  anki_as_code api backend-card-rendering [command]

Available Commands:
  all-tts-voices                 /anki.card_rendering.BackendCardRenderingService/AllTtsVoices
  compare-answer                 /anki.card_rendering.BackendCardRenderingService/CompareAnswer
  decode-iri-paths               /anki.card_rendering.BackendCardRenderingService/DecodeIriPaths
  encode-iri-paths               /anki.card_rendering.BackendCardRenderingService/EncodeIriPaths
  extract-av-tags                /anki.card_rendering.BackendCardRenderingService/ExtractAvTags
  extract-cloze-for-typing       /anki.card_rendering.BackendCardRenderingService/ExtractClozeForTyping
  extract-latex                  /anki.card_rendering.BackendCardRenderingService/ExtractLatex
  get-empty-cards                /anki.card_rendering.BackendCardRenderingService/GetEmptyCards
  html-to-text-line              /anki.card_rendering.BackendCardRenderingService/HtmlToTextLine
  render-existing-card           /anki.card_rendering.BackendCardRenderingService/RenderExistingCard
  render-markdown                /anki.card_rendering.BackendCardRenderingService/RenderMarkdown
  render-uncommitted-card        /anki.card_rendering.BackendCardRenderingService/RenderUncommittedCard
  render-uncommitted-card-legacy /anki.card_rendering.BackendCardRenderingService/RenderUncommittedCardLegacy
  strip-av-tags                  /anki.card_rendering.BackendCardRenderingService/StripAvTags
  strip-html                     /anki.card_rendering.BackendCardRenderingService/StripHtml
  write-tts-stream               /anki.card_rendering.BackendCardRenderingService/WriteTtsStream

Flags:
  -h, --help   help for backend-card-rendering

Use "anki_as_code api backend-card-rendering [command] --help" for more information about a command.

/anki.card_rendering.BackendCardRenderingService/AllTtsVoices

Request: anki.card_rendering.AllTtsVoicesRequest
Response: anki.card_rendering.AllTtsVoicesResponse

Request fields:
  validate: optional bool

Usage:
  anki_as_code api backend-card-rendering all-tts-voices [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for all-tts-voices
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/CompareAnswer

Request: anki.card_rendering.CompareAnswerRequest
Response: anki.generic.String

Request fields:
  expected: optional string
  provided: optional string
  combining: optional bool

Usage:
  anki_as_code api backend-card-rendering compare-answer [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for compare-answer
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/DecodeIriPaths

Request: anki.generic.String
Response: anki.generic.String

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-card-rendering decode-iri-paths [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for decode-iri-paths
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/EncodeIriPaths

Request: anki.generic.String
Response: anki.generic.String

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-card-rendering encode-iri-paths [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for encode-iri-paths
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/ExtractAvTags

Request: anki.card_rendering.ExtractAvTagsRequest
Response: anki.card_rendering.ExtractAvTagsResponse

Request fields:
  text: optional string
  question_side: optional bool

Usage:
  anki_as_code api backend-card-rendering extract-av-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extract-av-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/ExtractClozeForTyping

Request: anki.card_rendering.ExtractClozeForTypingRequest
Response: anki.generic.String

Request fields:
  text: optional string
  ordinal: optional uint32

Usage:
  anki_as_code api backend-card-rendering extract-cloze-for-typing [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extract-cloze-for-typing
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/ExtractLatex

Request: anki.card_rendering.ExtractLatexRequest
Response: anki.card_rendering.ExtractLatexResponse

Request fields:
  text: optional string
  svg: optional bool
  expand_clozes: optional bool

Usage:
  anki_as_code api backend-card-rendering extract-latex [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extract-latex
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/GetEmptyCards

Request: anki.generic.Empty
Response: anki.card_rendering.EmptyCardsReport

Usage:
  anki_as_code api backend-card-rendering get-empty-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-empty-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki_as_code api backend-card-rendering html-to-text-line

/anki.card_rendering.BackendCardRenderingService/HtmlToTextLine

Request: anki.card_rendering.HtmlToTextLineRequest
Response: anki.generic.String

Request fields:
  text: optional string
  preserve_media_filenames: optional bool

Usage:
  anki_as_code api backend-card-rendering html-to-text-line [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for html-to-text-line
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/RenderExistingCard

Request: anki.card_rendering.RenderExistingCardRequest
Response: anki.card_rendering.RenderCardResponse

Request fields:
  card_id: optional int64
  browser: optional bool
  partial_render: optional bool

Usage:
  anki_as_code api backend-card-rendering render-existing-card [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for render-existing-card
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/RenderMarkdown

Request: anki.card_rendering.RenderMarkdownRequest
Response: anki.generic.String

Request fields:
  markdown: optional string
  sanitize: optional bool

Usage:
  anki_as_code api backend-card-rendering render-markdown [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for render-markdown
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/RenderUncommittedCard

Request: anki.card_rendering.RenderUncommittedCardRequest
Response: anki.card_rendering.RenderCardResponse

Request fields:
  note: optional anki.notes.Note
  card_ord: optional uint32
  template: optional anki.notetypes.Notetype.Template
  fill_empty: optional bool
  partial_render: optional bool

Usage:
  anki_as_code api backend-card-rendering render-uncommitted-card [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for render-uncommitted-card
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/RenderUncommittedCardLegacy

Request: anki.card_rendering.RenderUncommittedCardLegacyRequest
Response: anki.card_rendering.RenderCardResponse

Request fields:
  note: optional anki.notes.Note
  card_ord: optional uint32
  template: optional bytes
  fill_empty: optional bool
  partial_render: optional bool

Usage:
  anki_as_code api backend-card-rendering render-uncommitted-card-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for render-uncommitted-card-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/StripAvTags

Request: anki.generic.String
Response: anki.generic.String

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-card-rendering strip-av-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for strip-av-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/StripHtml

Request: anki.card_rendering.StripHtmlRequest
Response: anki.generic.String

Request fields:
  text: optional string
  mode: optional anki.card_rendering.StripHtmlRequest.Mode

Usage:
  anki_as_code api backend-card-rendering strip-html [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for strip-html
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.BackendCardRenderingService/WriteTtsStream

Request: anki.card_rendering.WriteTtsStreamRequest
Response: anki.generic.Empty

Request fields:
  path: optional string
  voice_id: optional string
  speed: optional float
  text: optional string

Usage:
  anki_as_code api backend-card-rendering write-tts-stream [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for write-tts-stream
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.cards.BackendCardsService

Usage:
  anki_as_code api backend-cards [command]

Available Commands:
  get-card     /anki.cards.BackendCardsService/GetCard
  remove-cards /anki.cards.BackendCardsService/RemoveCards
  set-deck     /anki.cards.BackendCardsService/SetDeck
  set-flag     /anki.cards.BackendCardsService/SetFlag
  update-cards /anki.cards.BackendCardsService/UpdateCards

Flags:
  -h, --help   help for backend-cards

Use "anki_as_code api backend-cards [command] --help" for more information about a command.

/anki.cards.BackendCardsService/GetCard

Request: anki.cards.CardId
Response: anki.cards.Card

Request fields:
  cid: optional int64

Usage:
  anki_as_code api backend-cards get-card [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-card
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.cards.BackendCardsService/RemoveCards

Request: anki.cards.RemoveCardsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  card_ids: repeated int64

Usage:
  anki_as_code api backend-cards remove-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.cards.BackendCardsService/SetDeck

Request: anki.cards.SetDeckRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  card_ids: repeated int64
  deck_id: optional int64

Usage:
  anki_as_code api backend-cards set-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.cards.BackendCardsService/SetFlag

Request: anki.cards.SetFlagRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  card_ids: repeated int64
  flag: optional uint32

Usage:
  anki_as_code api backend-cards set-flag [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-flag
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.cards.BackendCardsService/UpdateCards

Request: anki.cards.UpdateCardsRequest
Response: anki.collection.OpChanges

Request fields:
  cards: repeated anki.cards.Card
  skip_undo_entry: optional bool

Usage:
  anki_as_code api backend-cards update-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.collection.BackendCollectionService

Usage:
  anki_as_code api backend-collection [command]

Available Commands:
  add-custom-undo-entry     /anki.collection.BackendCollectionService/AddCustomUndoEntry
  await-backup-completion   /anki.collection.BackendCollectionService/AwaitBackupCompletion
  check-database            /anki.collection.BackendCollectionService/CheckDatabase
  close-collection          /anki.collection.BackendCollectionService/CloseCollection
  create-backup             /anki.collection.BackendCollectionService/CreateBackup
  get-custom-colours        /anki.collection.BackendCollectionService/GetCustomColours
  get-undo-status           /anki.collection.BackendCollectionService/GetUndoStatus
  latest-progress           /anki.collection.BackendCollectionService/LatestProgress
  merge-undo-entries        /anki.collection.BackendCollectionService/MergeUndoEntries
  open-collection           /anki.collection.BackendCollectionService/OpenCollection
  redo                      /anki.collection.BackendCollectionService/Redo
  set-load-balancer-enabled /anki.collection.BackendCollectionService/SetLoadBalancerEnabled
  set-wants-abort           /anki.collection.BackendCollectionService/SetWantsAbort
  undo                      /anki.collection.BackendCollectionService/Undo

Flags:
  -h, --help   help for backend-collection

Use "anki_as_code api backend-collection [command] --help" for more information about a command.

anki_as_code api backend-collection add-custom-undo-entry

/anki.collection.BackendCollectionService/AddCustomUndoEntry

Request: anki.generic.String
Response: anki.generic.UInt32

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-collection add-custom-undo-entry [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-custom-undo-entry
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/AwaitBackupCompletion

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-collection await-backup-completion [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for await-backup-completion
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/CheckDatabase

Request: anki.generic.Empty
Response: anki.collection.CheckDatabaseResponse

Usage:
  anki_as_code api backend-collection check-database [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for check-database
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/CloseCollection

Request: anki.collection.CloseCollectionRequest
Response: anki.generic.Empty

Request fields:
  downgrade_to_schema11: optional bool

Usage:
  anki_as_code api backend-collection close-collection [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for close-collection
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/CreateBackup

Request: anki.collection.CreateBackupRequest
Response: anki.generic.Bool

Request fields:
  backup_folder: optional string
  force: optional bool
  wait_for_completion: optional bool

Usage:
  anki_as_code api backend-collection create-backup [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for create-backup
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/GetCustomColours

Request: anki.generic.Empty
Response: anki.collection.GetCustomColoursResponse

Usage:
  anki_as_code api backend-collection get-custom-colours [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-custom-colours
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/GetUndoStatus

Request: anki.generic.Empty
Response: anki.collection.UndoStatus

Usage:
  anki_as_code api backend-collection get-undo-status [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-undo-status
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/LatestProgress

Request: anki.generic.Empty
Response: anki.collection.Progress

Usage:
  anki_as_code api backend-collection latest-progress [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for latest-progress
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/MergeUndoEntries

Request: anki.generic.UInt32
Response: anki.collection.OpChanges

Request fields:
  val: optional uint32

Usage:
  anki_as_code api backend-collection merge-undo-entries [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for merge-undo-entries
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/OpenCollection

Request: anki.collection.OpenCollectionRequest
Response: anki.generic.Empty

Request fields:
  collection_path: optional string
  media_folder_path: optional string
  media_db_path: optional string

Usage:
  anki_as_code api backend-collection open-collection [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-collection
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/Redo

Request: anki.generic.Empty
Response: anki.collection.OpChangesAfterUndo

Usage:
  anki_as_code api backend-collection redo [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for redo
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/SetLoadBalancerEnabled

Request: anki.generic.Bool
Response: anki.collection.OpChanges

Request fields:
  val: optional bool

Usage:
  anki_as_code api backend-collection set-load-balancer-enabled [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-load-balancer-enabled
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/SetWantsAbort

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-collection set-wants-abort [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-wants-abort
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.BackendCollectionService/Undo

Request: anki.generic.Empty
Response: anki.collection.OpChangesAfterUndo

Usage:
  anki_as_code api backend-collection undo [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for undo
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.config.BackendConfigService

Usage:
  anki_as_code api backend-config [command]

Available Commands:
  get-all-config          /anki.config.BackendConfigService/GetAllConfig
  get-config-bool         /anki.config.BackendConfigService/GetConfigBool
  get-config-json         /anki.config.BackendConfigService/GetConfigJson
  get-config-string       /anki.config.BackendConfigService/GetConfigString
  get-preferences         /anki.config.BackendConfigService/GetPreferences
  remove-config           /anki.config.BackendConfigService/RemoveConfig
  set-config-bool         /anki.config.BackendConfigService/SetConfigBool
  set-config-json         /anki.config.BackendConfigService/SetConfigJson
  set-config-json-no-undo /anki.config.BackendConfigService/SetConfigJsonNoUndo
  set-config-string       /anki.config.BackendConfigService/SetConfigString
  set-preferences         /anki.config.BackendConfigService/SetPreferences

Flags:
  -h, --help   help for backend-config

Use "anki_as_code api backend-config [command] --help" for more information about a command.

/anki.config.BackendConfigService/GetAllConfig

Request: anki.generic.Empty
Response: anki.generic.Json

Usage:
  anki_as_code api backend-config get-all-config [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-all-config
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.BackendConfigService/GetConfigBool

Request: anki.config.GetConfigBoolRequest
Response: anki.generic.Bool

Request fields:
  key: optional anki.config.ConfigKey.Bool

Usage:
  anki_as_code api backend-config get-config-bool [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-config-bool
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.BackendConfigService/GetConfigJson

Request: anki.generic.String
Response: anki.generic.Json

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-config get-config-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-config-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.BackendConfigService/GetConfigString

Request: anki.config.GetConfigStringRequest
Response: anki.generic.String

Request fields:
  key: optional anki.config.ConfigKey.String

Usage:
  anki_as_code api backend-config get-config-string [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-config-string
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.BackendConfigService/GetPreferences

Request: anki.generic.Empty
Response: anki.config.Preferences

Usage:
  anki_as_code api backend-config get-preferences [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-preferences
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.BackendConfigService/RemoveConfig

Request: anki.generic.String
Response: anki.collection.OpChanges

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-config remove-config [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-config
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.BackendConfigService/SetConfigBool

Request: anki.config.SetConfigBoolRequest
Response: anki.collection.OpChanges

Request fields:
  key: optional anki.config.ConfigKey.Bool
  value: optional bool
  undoable: optional bool

Usage:
  anki_as_code api backend-config set-config-bool [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-config-bool
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.BackendConfigService/SetConfigJson

Request: anki.config.SetConfigJsonRequest
Response: anki.collection.OpChanges

Request fields:
  key: optional string
  value_json: optional bytes
  undoable: optional bool

Usage:
  anki_as_code api backend-config set-config-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-config-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.BackendConfigService/SetConfigJsonNoUndo

Request: anki.config.SetConfigJsonRequest
Response: anki.generic.Empty

Request fields:
  key: optional string
  value_json: optional bytes
  undoable: optional bool

Usage:
  anki_as_code api backend-config set-config-json-no-undo [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-config-json-no-undo
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.BackendConfigService/SetConfigString

Request: anki.config.SetConfigStringRequest
Response: anki.collection.OpChanges

Request fields:
  key: optional anki.config.ConfigKey.String
  value: optional string
  undoable: optional bool

Usage:
  anki_as_code api backend-config set-config-string [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-config-string
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.BackendConfigService/SetPreferences

Request: anki.config.Preferences
Response: anki.collection.OpChanges

Request fields:
  scheduling: optional anki.config.Preferences.Scheduling
  reviewing: optional anki.config.Preferences.Reviewing
  editing: optional anki.config.Preferences.Editing
  backups: optional anki.config.Preferences.BackupLimits

Usage:
  anki_as_code api backend-config set-preferences [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-preferences
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.deck_config.BackendDeckConfigService

Usage:
  anki_as_code api backend-deck-config [command]

Available Commands:
  add-or-update-deck-config-legacy /anki.deck_config.BackendDeckConfigService/AddOrUpdateDeckConfigLegacy
  all-deck-config-legacy           /anki.deck_config.BackendDeckConfigService/AllDeckConfigLegacy
  get-deck-config                  /anki.deck_config.BackendDeckConfigService/GetDeckConfig
  get-deck-config-legacy           /anki.deck_config.BackendDeckConfigService/GetDeckConfigLegacy
  get-deck-configs-for-update      /anki.deck_config.BackendDeckConfigService/GetDeckConfigsForUpdate
  get-ignored-before-count         /anki.deck_config.BackendDeckConfigService/GetIgnoredBeforeCount
  get-retention-workload           /anki.deck_config.BackendDeckConfigService/GetRetentionWorkload
  new-deck-config-legacy           /anki.deck_config.BackendDeckConfigService/NewDeckConfigLegacy
  remove-deck-config               /anki.deck_config.BackendDeckConfigService/RemoveDeckConfig
  update-deck-configs              /anki.deck_config.BackendDeckConfigService/UpdateDeckConfigs

Flags:
  -h, --help   help for backend-deck-config

Use "anki_as_code api backend-deck-config [command] --help" for more information about a command.

/anki.deck_config.BackendDeckConfigService/AddOrUpdateDeckConfigLegacy

Request: anki.generic.Json
Response: anki.deck_config.DeckConfigId

Request fields:
  json: optional bytes

Usage:
  anki_as_code api backend-deck-config add-or-update-deck-config-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-or-update-deck-config-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.BackendDeckConfigService/AllDeckConfigLegacy

Request: anki.generic.Empty
Response: anki.generic.Json

Usage:
  anki_as_code api backend-deck-config all-deck-config-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for all-deck-config-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.BackendDeckConfigService/GetDeckConfig

Request: anki.deck_config.DeckConfigId
Response: anki.deck_config.DeckConfig

Request fields:
  dcid: optional int64

Usage:
  anki_as_code api backend-deck-config get-deck-config [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-config
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.BackendDeckConfigService/GetDeckConfigLegacy

Request: anki.deck_config.DeckConfigId
Response: anki.generic.Json

Request fields:
  dcid: optional int64

Usage:
  anki_as_code api backend-deck-config get-deck-config-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-config-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.BackendDeckConfigService/GetDeckConfigsForUpdate

Request: anki.decks.DeckId
Response: anki.deck_config.DeckConfigsForUpdate

Request fields:
  did: optional int64

Usage:
  anki_as_code api backend-deck-config get-deck-configs-for-update [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-configs-for-update
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.BackendDeckConfigService/GetIgnoredBeforeCount

Request: anki.deck_config.GetIgnoredBeforeCountRequest
Response: anki.deck_config.GetIgnoredBeforeCountResponse

Request fields:
  ignore_revlogs_before_date: optional string
  search: optional string

Usage:
  anki_as_code api backend-deck-config get-ignored-before-count [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-ignored-before-count
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.BackendDeckConfigService/GetRetentionWorkload

Request: anki.deck_config.GetRetentionWorkloadRequest
Response: anki.deck_config.GetRetentionWorkloadResponse

Request fields:
  w: repeated float
  search: optional string

Usage:
  anki_as_code api backend-deck-config get-retention-workload [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-retention-workload
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.BackendDeckConfigService/NewDeckConfigLegacy

Request: anki.generic.Empty
Response: anki.generic.Json

Usage:
  anki_as_code api backend-deck-config new-deck-config-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for new-deck-config-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.BackendDeckConfigService/RemoveDeckConfig

Request: anki.deck_config.DeckConfigId
Response: anki.generic.Empty

Request fields:
  dcid: optional int64

Usage:
  anki_as_code api backend-deck-config remove-deck-config [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-deck-config
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.BackendDeckConfigService/UpdateDeckConfigs

Request: anki.deck_config.UpdateDeckConfigsRequest
Response: anki.collection.OpChanges

Request fields:
  target_deck_id: optional int64
  configs: repeated anki.deck_config.DeckConfig
  removed_config_ids: repeated int64
  mode: optional anki.deck_config.UpdateDeckConfigsMode
  card_state_customizer: optional string
  limits: optional anki.deck_config.DeckConfigsForUpdate.CurrentDeck.Limits
  new_cards_ignore_review_limit: optional bool
  fsrs: optional bool
  apply_all_parent_limits: optional bool
  fsrs_reschedule: optional bool
  fsrs_health_check: optional bool

Usage:
  anki_as_code api backend-deck-config update-deck-configs [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-deck-configs
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.decks.BackendDecksService

Usage:
  anki_as_code api backend-decks [command]

Available Commands:
  add-deck                    /anki.decks.BackendDecksService/AddDeck
  add-deck-legacy             /anki.decks.BackendDecksService/AddDeckLegacy
  add-or-update-deck-legacy   /anki.decks.BackendDecksService/AddOrUpdateDeckLegacy
  add-or-update-filtered-deck /anki.decks.BackendDecksService/AddOrUpdateFilteredDeck
  deck-tree                   /anki.decks.BackendDecksService/DeckTree
  deck-tree-legacy            /anki.decks.BackendDecksService/DeckTreeLegacy
  filtered-deck-order-labels  /anki.decks.BackendDecksService/FilteredDeckOrderLabels
  get-all-decks-legacy        /anki.decks.BackendDecksService/GetAllDecksLegacy
  get-current-deck            /anki.decks.BackendDecksService/GetCurrentDeck
  get-deck                    /anki.decks.BackendDecksService/GetDeck
  get-deck-and-child-names    /anki.decks.BackendDecksService/GetDeckAndChildNames
  get-deck-id-by-name         /anki.decks.BackendDecksService/GetDeckIdByName
  get-deck-legacy             /anki.decks.BackendDecksService/GetDeckLegacy
  get-deck-names              /anki.decks.BackendDecksService/GetDeckNames
  get-or-create-filtered-deck /anki.decks.BackendDecksService/GetOrCreateFilteredDeck
  new-deck                    /anki.decks.BackendDecksService/NewDeck
  new-deck-legacy             /anki.decks.BackendDecksService/NewDeckLegacy
  remove-decks                /anki.decks.BackendDecksService/RemoveDecks
  rename-deck                 /anki.decks.BackendDecksService/RenameDeck
  reparent-decks              /anki.decks.BackendDecksService/ReparentDecks
  set-current-deck            /anki.decks.BackendDecksService/SetCurrentDeck
  set-deck-collapsed          /anki.decks.BackendDecksService/SetDeckCollapsed
  update-deck                 /anki.decks.BackendDecksService/UpdateDeck
  update-deck-legacy          /anki.decks.BackendDecksService/UpdateDeckLegacy

Flags:
  -h, --help   help for backend-decks

Use "anki_as_code api backend-decks [command] --help" for more information about a command.

/anki.decks.BackendDecksService/AddDeck

Request: anki.decks.Deck
Response: anki.collection.OpChangesWithId

Request fields:
  id: optional int64
  name: optional string
  mtime_secs: optional int64
  usn: optional int32
  common: optional anki.decks.Deck.Common
  normal: optional anki.decks.Deck.Normal
  filtered: optional anki.decks.Deck.Filtered

Usage:
  anki_as_code api backend-decks add-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/AddDeckLegacy

Request: anki.generic.Json
Response: anki.collection.OpChangesWithId

Request fields:
  json: optional bytes

Usage:
  anki_as_code api backend-decks add-deck-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-deck-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/AddOrUpdateDeckLegacy

Request: anki.decks.AddOrUpdateDeckLegacyRequest
Response: anki.decks.DeckId

Request fields:
  deck: optional bytes
  preserve_usn_and_mtime: optional bool

Usage:
  anki_as_code api backend-decks add-or-update-deck-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-or-update-deck-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/AddOrUpdateFilteredDeck

Request: anki.decks.FilteredDeckForUpdate
Response: anki.collection.OpChangesWithId

Request fields:
  id: optional int64
  name: optional string
  config: optional anki.decks.Deck.Filtered
  allow_empty: optional bool

Usage:
  anki_as_code api backend-decks add-or-update-filtered-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-or-update-filtered-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/DeckTree

Request: anki.decks.DeckTreeRequest
Response: anki.decks.DeckTreeNode

Request fields:
  now: optional int64

Usage:
  anki_as_code api backend-decks deck-tree [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for deck-tree
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/DeckTreeLegacy

Request: anki.generic.Empty
Response: anki.generic.Json

Usage:
  anki_as_code api backend-decks deck-tree-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for deck-tree-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/FilteredDeckOrderLabels

Request: anki.generic.Empty
Response: anki.generic.StringList

Usage:
  anki_as_code api backend-decks filtered-deck-order-labels [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for filtered-deck-order-labels
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/GetAllDecksLegacy

Request: anki.generic.Empty
Response: anki.generic.Json

Usage:
  anki_as_code api backend-decks get-all-decks-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-all-decks-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/GetCurrentDeck

Request: anki.generic.Empty
Response: anki.decks.Deck

Usage:
  anki_as_code api backend-decks get-current-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-current-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/GetDeck

Request: anki.decks.DeckId
Response: anki.decks.Deck

Request fields:
  did: optional int64

Usage:
  anki_as_code api backend-decks get-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/GetDeckAndChildNames

Request: anki.decks.DeckId
Response: anki.decks.DeckNames

Request fields:
  did: optional int64

Usage:
  anki_as_code api backend-decks get-deck-and-child-names [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-and-child-names
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/GetDeckIdByName

Request: anki.generic.String
Response: anki.decks.DeckId

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-decks get-deck-id-by-name [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-id-by-name
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/GetDeckLegacy

Request: anki.decks.DeckId
Response: anki.generic.Json

Request fields:
  did: optional int64

Usage:
  anki_as_code api backend-decks get-deck-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/GetDeckNames

Request: anki.decks.GetDeckNamesRequest
Response: anki.decks.DeckNames

Request fields:
  skip_empty_default: optional bool
  include_filtered: optional bool

Usage:
  anki_as_code api backend-decks get-deck-names [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-names
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/GetOrCreateFilteredDeck

Request: anki.decks.DeckId
Response: anki.decks.FilteredDeckForUpdate

Request fields:
  did: optional int64

Usage:
  anki_as_code api backend-decks get-or-create-filtered-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-or-create-filtered-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/NewDeck

Request: anki.generic.Empty
Response: anki.decks.Deck

Usage:
  anki_as_code api backend-decks new-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for new-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/NewDeckLegacy

Request: anki.generic.Bool
Response: anki.generic.Json

Request fields:
  val: optional bool

Usage:
  anki_as_code api backend-decks new-deck-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for new-deck-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/RemoveDecks

Request: anki.decks.DeckIds
Response: anki.collection.OpChangesWithCount

Request fields:
  dids: repeated int64

Usage:
  anki_as_code api backend-decks remove-decks [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-decks
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/RenameDeck

Request: anki.decks.RenameDeckRequest
Response: anki.collection.OpChanges

Request fields:
  deck_id: optional int64
  new_name: optional string

Usage:
  anki_as_code api backend-decks rename-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for rename-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/ReparentDecks

Request: anki.decks.ReparentDecksRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  deck_ids: repeated int64
  new_parent: optional int64

Usage:
  anki_as_code api backend-decks reparent-decks [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for reparent-decks
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/SetCurrentDeck

Request: anki.decks.DeckId
Response: anki.collection.OpChanges

Request fields:
  did: optional int64

Usage:
  anki_as_code api backend-decks set-current-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-current-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/SetDeckCollapsed

Request: anki.decks.SetDeckCollapsedRequest
Response: anki.collection.OpChanges

Request fields:
  deck_id: optional int64
  collapsed: optional bool
  scope: optional anki.decks.SetDeckCollapsedRequest.Scope

Usage:
  anki_as_code api backend-decks set-deck-collapsed [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-deck-collapsed
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/UpdateDeck

Request: anki.decks.Deck
Response: anki.collection.OpChanges

Request fields:
  id: optional int64
  name: optional string
  mtime_secs: optional int64
  usn: optional int32
  common: optional anki.decks.Deck.Common
  normal: optional anki.decks.Deck.Normal
  filtered: optional anki.decks.Deck.Filtered

Usage:
  anki_as_code api backend-decks update-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.BackendDecksService/UpdateDeckLegacy

Request: anki.generic.Json
Response: anki.collection.OpChanges

Request fields:
  json: optional bytes

Usage:
  anki_as_code api backend-decks update-deck-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-deck-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.frontend.BackendFrontendService

Usage:
  anki_as_code api backend-frontend [command]

Available Commands:
  ask-user                           /anki.frontend.BackendFrontendService/AskUser
  close-add-cards                    /anki.frontend.BackendFrontendService/CloseAddCards
  close-edit-current                 /anki.frontend.BackendFrontendService/CloseEditCurrent
  convert-pasted-image               /anki.frontend.BackendFrontendService/ConvertPastedImage
  deck-options-ready                 /anki.frontend.BackendFrontendService/deckOptionsReady
  deck-options-require-close         /anki.frontend.BackendFrontendService/deckOptionsRequireClose
  get-meta-json                      /anki.frontend.BackendFrontendService/GetMetaJson
  get-profile-config-json            /anki.frontend.BackendFrontendService/GetProfileConfigJson
  get-scheduling-states-with-context /anki.frontend.BackendFrontendService/GetSchedulingStatesWithContext
  import-dialog-require-close        /anki.frontend.BackendFrontendService/ImportDialogRequireClose
  import-done                        /anki.frontend.BackendFrontendService/ImportDone
  open-cards-dialog                  /anki.frontend.BackendFrontendService/OpenCardsDialog
  open-fields-dialog                 /anki.frontend.BackendFrontendService/OpenFieldsDialog
  open-file-picker                   /anki.frontend.BackendFrontendService/OpenFilePicker
  open-link                          /anki.frontend.BackendFrontendService/OpenLink
  open-media                         /anki.frontend.BackendFrontendService/OpenMedia
  play-file                          /anki.frontend.BackendFrontendService/PlayFile
  read-clipboard                     /anki.frontend.BackendFrontendService/ReadClipboard
  record-audio                       /anki.frontend.BackendFrontendService/RecordAudio
  save-custom-colours                /anki.frontend.BackendFrontendService/SaveCustomColours
  search-in-browser                  /anki.frontend.BackendFrontendService/SearchInBrowser
  set-meta-json                      /anki.frontend.BackendFrontendService/SetMetaJson
  set-profile-config-json            /anki.frontend.BackendFrontendService/SetProfileConfigJson
  set-scheduling-states              /anki.frontend.BackendFrontendService/SetSchedulingStates
  show-in-media-folder               /anki.frontend.BackendFrontendService/ShowInMediaFolder
  show-message-box                   /anki.frontend.BackendFrontendService/ShowMessageBox
  write-clipboard                    /anki.frontend.BackendFrontendService/WriteClipboard

Flags:
  -h, --help   help for backend-frontend

Use "anki_as_code api backend-frontend [command] --help" for more information about a command.

/anki.frontend.BackendFrontendService/AskUser

Request: anki.frontend.AskUserRequest
Response: anki.generic.Bool

Request fields:
  text: optional string
  help: optional anki.frontend.Help
  title: optional string
  default_no: optional bool

Usage:
  anki_as_code api backend-frontend ask-user [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for ask-user
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/CloseAddCards

Request: anki.generic.Bool
Response: anki.generic.Empty

Request fields:
  val: optional bool

Usage:
  anki_as_code api backend-frontend close-add-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for close-add-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/CloseEditCurrent

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-frontend close-edit-current [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for close-edit-current
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/ConvertPastedImage

Request: anki.frontend.ConvertPastedImageRequest
Response: anki.frontend.ConvertPastedImageResponse

Request fields:
  data: optional bytes
  ext: optional string

Usage:
  anki_as_code api backend-frontend convert-pasted-image [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for convert-pasted-image
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/deckOptionsReady

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-frontend deck-options-ready [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for deck-options-ready
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/deckOptionsRequireClose

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-frontend deck-options-require-close [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for deck-options-require-close
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/GetMetaJson

Request: anki.generic.String
Response: anki.generic.Json

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-frontend get-meta-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-meta-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/GetProfileConfigJson

Request: anki.generic.String
Response: anki.generic.Json

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-frontend get-profile-config-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-profile-config-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/GetSchedulingStatesWithContext

Request: anki.generic.Empty
Response: anki.frontend.SchedulingStatesWithContext

Usage:
  anki_as_code api backend-frontend get-scheduling-states-with-context [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-scheduling-states-with-context
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/ImportDialogRequireClose

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-frontend import-dialog-require-close [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-dialog-require-close
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/ImportDone

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-frontend import-done [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-done
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/OpenCardsDialog

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-frontend open-cards-dialog [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-cards-dialog
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/OpenFieldsDialog

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-frontend open-fields-dialog [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-fields-dialog
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/OpenFilePicker

Request: anki.frontend.openFilePickerRequest
Response: anki.generic.String

Request fields:
  title: optional string
  key: optional string
  filter_description: optional string
  extensions: repeated string

Usage:
  anki_as_code api backend-frontend open-file-picker [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-file-picker
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/OpenLink

Request: anki.generic.String
Response: anki.generic.Empty

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-frontend open-link [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-link
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/OpenMedia

Request: anki.generic.String
Response: anki.generic.Empty

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-frontend open-media [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-media
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/PlayFile

Request: anki.generic.String
Response: anki.generic.Empty

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-frontend play-file [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for play-file
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/ReadClipboard

Request: anki.frontend.ReadClipboardRequest
Response: anki.frontend.ReadClipboardResponse

Request fields:
  types: repeated string

Usage:
  anki_as_code api backend-frontend read-clipboard [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for read-clipboard
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/RecordAudio

Request: anki.generic.Empty
Response: anki.generic.String

Usage:
  anki_as_code api backend-frontend record-audio [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for record-audio
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/SaveCustomColours

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-frontend save-custom-colours [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for save-custom-colours
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/SearchInBrowser

Request: anki.search.SearchNode
Response: anki.generic.Empty

Request fields:
  group: optional anki.search.SearchNode.Group
  negated: optional anki.search.SearchNode
  parsable_text: optional string
  template: optional uint32
  nid: optional int64
  dupe: optional anki.search.SearchNode.Dupe
  field_name: optional string
  rated: optional anki.search.SearchNode.Rated
  added_in_days: optional uint32
  due_in_days: optional int32
  flag: optional anki.search.SearchNode.Flag
  card_state: optional anki.search.SearchNode.CardState
  nids: optional anki.search.SearchNode.IdList
  edited_in_days: optional uint32
  deck: optional string
  due_on_day: optional int32
  tag: optional string
  note: optional string
  introduced_in_days: optional uint32
  field: optional anki.search.SearchNode.Field
  literal_text: optional string

Usage:
  anki_as_code api backend-frontend search-in-browser [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for search-in-browser
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/SetMetaJson

Request: anki.frontend.SetSettingJsonRequest
Response: anki.generic.Empty

Request fields:
  key: optional string
  value_json: optional bytes

Usage:
  anki_as_code api backend-frontend set-meta-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-meta-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/SetProfileConfigJson

Request: anki.frontend.SetSettingJsonRequest
Response: anki.generic.Empty

Request fields:
  key: optional string
  value_json: optional bytes

Usage:
  anki_as_code api backend-frontend set-profile-config-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-profile-config-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/SetSchedulingStates

Request: anki.frontend.SetSchedulingStatesRequest
Response: anki.generic.Empty

Request fields:
  key: optional string
  states: optional anki.scheduler.SchedulingStates

Usage:
  anki_as_code api backend-frontend set-scheduling-states [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-scheduling-states
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/ShowInMediaFolder

Request: anki.generic.String
Response: anki.generic.Empty

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-frontend show-in-media-folder [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for show-in-media-folder
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/ShowMessageBox

Request: anki.frontend.ShowMessageBoxRequest
Response: anki.generic.Empty

Request fields:
  text: optional string
  type: optional anki.frontend.MessageBoxType
  help: optional anki.frontend.Help
  title: optional string
  text_format: optional string

Usage:
  anki_as_code api backend-frontend show-message-box [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for show-message-box
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.BackendFrontendService/WriteClipboard

Request: anki.frontend.WriteClipboardRequest
Response: anki.generic.Empty

Request fields:
  data: repeated anki.frontend.WriteClipboardRequest.DataEntry

Usage:
  anki_as_code api backend-frontend write-clipboard [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for write-clipboard
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.github.BackendGithubService

Usage:
  anki_as_code api backend-github [command]

Available Commands:
  download-release   /anki.github.BackendGithubService/DownloadRelease
  get-latest-release /anki.github.BackendGithubService/GetLatestRelease

Flags:
  -h, --help   help for backend-github

Use "anki_as_code api backend-github [command] --help" for more information about a command.

/anki.github.BackendGithubService/DownloadRelease

Request: anki.github.GithubRelease
Response: anki.generic.String

Request fields:
  tag_name: optional string
  filename: optional string
  url: optional string
  checksum: optional string

Usage:
  anki_as_code api backend-github download-release [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for download-release
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.github.BackendGithubService/GetLatestRelease

Request: anki.github.LatestReleaseRequest
Response: anki.github.GithubRelease

Request fields:
  include_prerelease: optional bool

Usage:
  anki_as_code api backend-github get-latest-release [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-latest-release
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.i18n.BackendI18nService

Usage:
  anki_as_code api backend-i18n [command]

Available Commands:
  format-timespan  /anki.i18n.BackendI18nService/FormatTimespan
  i18n-resources   /anki.i18n.BackendI18nService/I18nResources
  translate-string /anki.i18n.BackendI18nService/TranslateString

Flags:
  -h, --help   help for backend-i18n

Use "anki_as_code api backend-i18n [command] --help" for more information about a command.

/anki.i18n.BackendI18nService/FormatTimespan

Request: anki.i18n.FormatTimespanRequest
Response: anki.generic.String

Request fields:
  seconds: optional float
  context: optional anki.i18n.FormatTimespanRequest.Context

Usage:
  anki_as_code api backend-i18n format-timespan [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for format-timespan
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.i18n.BackendI18nService/I18nResources

Request: anki.i18n.I18nResourcesRequest
Response: anki.generic.Json

Request fields:
  modules: repeated string

Usage:
  anki_as_code api backend-i18n i18n-resources [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for i18n-resources
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.i18n.BackendI18nService/TranslateString

Request: anki.i18n.TranslateStringRequest
Response: anki.generic.String

Request fields:
  module_index: optional uint32
  message_index: optional uint32
  args: repeated anki.i18n.TranslateStringRequest.ArgsEntry

Usage:
  anki_as_code api backend-i18n translate-string [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for translate-string
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.image_occlusion.BackendImageOcclusionService

Usage:
  anki_as_code api backend-image-occlusion [command]

Available Commands:
  add-image-occlusion-note     /anki.image_occlusion.BackendImageOcclusionService/AddImageOcclusionNote
  add-image-occlusion-notetype /anki.image_occlusion.BackendImageOcclusionService/AddImageOcclusionNotetype
  get-image-for-occlusion      /anki.image_occlusion.BackendImageOcclusionService/GetImageForOcclusion
  get-image-occlusion-fields   /anki.image_occlusion.BackendImageOcclusionService/GetImageOcclusionFields
  get-image-occlusion-note     /anki.image_occlusion.BackendImageOcclusionService/GetImageOcclusionNote
  update-image-occlusion-note  /anki.image_occlusion.BackendImageOcclusionService/UpdateImageOcclusionNote

Flags:
  -h, --help   help for backend-image-occlusion

Use "anki_as_code api backend-image-occlusion [command] --help" for more information about a command.

/anki.image_occlusion.BackendImageOcclusionService/AddImageOcclusionNote

Request: anki.image_occlusion.AddImageOcclusionNoteRequest
Response: anki.collection.OpChanges

Request fields:
  image_path: optional string
  occlusions: optional string
  header: optional string
  back_extra: optional string
  tags: repeated string
  notetype_id: optional int64

Usage:
  anki_as_code api backend-image-occlusion add-image-occlusion-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-image-occlusion-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.image_occlusion.BackendImageOcclusionService/AddImageOcclusionNotetype

Request: anki.generic.Empty
Response: anki.collection.OpChanges

Usage:
  anki_as_code api backend-image-occlusion add-image-occlusion-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-image-occlusion-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.image_occlusion.BackendImageOcclusionService/GetImageForOcclusion

Request: anki.image_occlusion.GetImageForOcclusionRequest
Response: anki.image_occlusion.GetImageForOcclusionResponse

Request fields:
  path: optional string

Usage:
  anki_as_code api backend-image-occlusion get-image-for-occlusion [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-image-for-occlusion
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.image_occlusion.BackendImageOcclusionService/GetImageOcclusionFields

Request: anki.image_occlusion.GetImageOcclusionFieldsRequest
Response: anki.image_occlusion.GetImageOcclusionFieldsResponse

Request fields:
  notetype_id: optional int64

Usage:
  anki_as_code api backend-image-occlusion get-image-occlusion-fields [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-image-occlusion-fields
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.image_occlusion.BackendImageOcclusionService/GetImageOcclusionNote

Request: anki.image_occlusion.GetImageOcclusionNoteRequest
Response: anki.image_occlusion.GetImageOcclusionNoteResponse

Request fields:
  note_id: optional int64

Usage:
  anki_as_code api backend-image-occlusion get-image-occlusion-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-image-occlusion-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.image_occlusion.BackendImageOcclusionService/UpdateImageOcclusionNote

Request: anki.image_occlusion.UpdateImageOcclusionNoteRequest
Response: anki.collection.OpChanges

Request fields:
  note_id: optional int64
  occlusions: optional string
  header: optional string
  back_extra: optional string
  tags: repeated string

Usage:
  anki_as_code api backend-image-occlusion update-image-occlusion-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-image-occlusion-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.import_export.BackendImportExportService

Usage:
  anki_as_code api backend-import-export [command]

Available Commands:
  export-anki-package             /anki.import_export.BackendImportExportService/ExportAnkiPackage
  export-card-csv                 /anki.import_export.BackendImportExportService/ExportCardCsv
  export-collection-package       /anki.import_export.BackendImportExportService/ExportCollectionPackage
  export-note-csv                 /anki.import_export.BackendImportExportService/ExportNoteCsv
  get-csv-metadata                /anki.import_export.BackendImportExportService/GetCsvMetadata
  get-import-anki-package-presets /anki.import_export.BackendImportExportService/GetImportAnkiPackagePresets
  import-anki-package             /anki.import_export.BackendImportExportService/ImportAnkiPackage
  import-collection-package       /anki.import_export.BackendImportExportService/ImportCollectionPackage
  import-csv                      /anki.import_export.BackendImportExportService/ImportCsv
  import-json-file                /anki.import_export.BackendImportExportService/ImportJsonFile
  import-json-string              /anki.import_export.BackendImportExportService/ImportJsonString

Flags:
  -h, --help   help for backend-import-export

Use "anki_as_code api backend-import-export [command] --help" for more information about a command.

/anki.import_export.BackendImportExportService/ExportAnkiPackage

Request: anki.import_export.ExportAnkiPackageRequest
Response: anki.generic.UInt32

Request fields:
  out_path: optional string
  options: optional anki.import_export.ExportAnkiPackageOptions
  limit: optional anki.import_export.ExportLimit

Usage:
  anki_as_code api backend-import-export export-anki-package [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for export-anki-package
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.BackendImportExportService/ExportCardCsv

Request: anki.import_export.ExportCardCsvRequest
Response: anki.generic.UInt32

Request fields:
  out_path: optional string
  with_html: optional bool
  limit: optional anki.import_export.ExportLimit

Usage:
  anki_as_code api backend-import-export export-card-csv [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for export-card-csv
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.BackendImportExportService/ExportCollectionPackage

Request: anki.import_export.ExportCollectionPackageRequest
Response: anki.generic.Empty

Request fields:
  out_path: optional string
  include_media: optional bool
  legacy: optional bool

Usage:
  anki_as_code api backend-import-export export-collection-package [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for export-collection-package
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.BackendImportExportService/ExportNoteCsv

Request: anki.import_export.ExportNoteCsvRequest
Response: anki.generic.UInt32

Request fields:
  out_path: optional string
  with_html: optional bool
  with_tags: optional bool
  with_deck: optional bool
  with_notetype: optional bool
  with_guid: optional bool
  limit: optional anki.import_export.ExportLimit

Usage:
  anki_as_code api backend-import-export export-note-csv [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for export-note-csv
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.BackendImportExportService/GetCsvMetadata

Request: anki.import_export.CsvMetadataRequest
Response: anki.import_export.CsvMetadata

Request fields:
  path: optional string
  delimiter: optional anki.import_export.CsvMetadata.Delimiter
  notetype_id: optional int64
  deck_id: optional int64
  is_html: optional bool

Usage:
  anki_as_code api backend-import-export get-csv-metadata [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-csv-metadata
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.BackendImportExportService/GetImportAnkiPackagePresets

Request: anki.generic.Empty
Response: anki.import_export.ImportAnkiPackageOptions

Usage:
  anki_as_code api backend-import-export get-import-anki-package-presets [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-import-anki-package-presets
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.BackendImportExportService/ImportAnkiPackage

Request: anki.import_export.ImportAnkiPackageRequest
Response: anki.import_export.ImportResponse

Request fields:
  package_path: optional string
  options: optional anki.import_export.ImportAnkiPackageOptions

Usage:
  anki_as_code api backend-import-export import-anki-package [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-anki-package
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.BackendImportExportService/ImportCollectionPackage

Request: anki.import_export.ImportCollectionPackageRequest
Response: anki.generic.Empty

Request fields:
  col_path: optional string
  backup_path: optional string
  media_folder: optional string
  media_db: optional string

Usage:
  anki_as_code api backend-import-export import-collection-package [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-collection-package
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.BackendImportExportService/ImportCsv

Request: anki.import_export.ImportCsvRequest
Response: anki.import_export.ImportResponse

Request fields:
  path: optional string
  metadata: optional anki.import_export.CsvMetadata

Usage:
  anki_as_code api backend-import-export import-csv [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-csv
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.BackendImportExportService/ImportJsonFile

Request: anki.generic.String
Response: anki.import_export.ImportResponse

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-import-export import-json-file [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-json-file
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.BackendImportExportService/ImportJsonString

Request: anki.generic.String
Response: anki.import_export.ImportResponse

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-import-export import-json-string [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-json-string
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.links.BackendLinksService

Usage:
  anki_as_code api backend-links [command]

Available Commands:
  help-page-link /anki.links.BackendLinksService/HelpPageLink

Flags:
  -h, --help   help for backend-links

Use "anki_as_code api backend-links [command] --help" for more information about a command.

anki_as_code api backend-links help-page-link

/anki.links.BackendLinksService/HelpPageLink

Request: anki.links.HelpPageLinkRequest
Response: anki.generic.String

Request fields:
  page: optional anki.links.HelpPageLinkRequest.HelpPage

Usage:
  anki_as_code api backend-links help-page-link [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for help-page-link
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.media.BackendMediaService

Usage:
  anki_as_code api backend-media [command]

Available Commands:
  add-media-file             /anki.media.BackendMediaService/AddMediaFile
  add-media-from-path        /anki.media.BackendMediaService/AddMediaFromPath
  add-media-from-url         /anki.media.BackendMediaService/AddMediaFromUrl
  check-media                /anki.media.BackendMediaService/CheckMedia
  empty-trash                /anki.media.BackendMediaService/EmptyTrash
  extract-media-files        /anki.media.BackendMediaService/ExtractMediaFiles
  extract-static-media-files /anki.media.BackendMediaService/ExtractStaticMediaFiles
  get-absolute-media-path    /anki.media.BackendMediaService/GetAbsoluteMediaPath
  restore-trash              /anki.media.BackendMediaService/RestoreTrash
  trash-media-files          /anki.media.BackendMediaService/TrashMediaFiles

Flags:
  -h, --help   help for backend-media

Use "anki_as_code api backend-media [command] --help" for more information about a command.

/anki.media.BackendMediaService/AddMediaFile

Request: anki.media.AddMediaFileRequest
Response: anki.generic.String

Request fields:
  desired_name: optional string
  data: optional bytes

Usage:
  anki_as_code api backend-media add-media-file [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-media-file
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.BackendMediaService/AddMediaFromPath

Request: anki.media.AddMediaFromPathRequest
Response: anki.generic.String

Request fields:
  path: optional string

Usage:
  anki_as_code api backend-media add-media-from-path [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-media-from-path
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.BackendMediaService/AddMediaFromUrl

Request: anki.media.AddMediaFromUrlRequest
Response: anki.media.AddMediaFromUrlResponse

Request fields:
  url: optional string

Usage:
  anki_as_code api backend-media add-media-from-url [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-media-from-url
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.BackendMediaService/CheckMedia

Request: anki.generic.Empty
Response: anki.media.CheckMediaResponse

Usage:
  anki_as_code api backend-media check-media [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for check-media
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.BackendMediaService/EmptyTrash

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-media empty-trash [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for empty-trash
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.BackendMediaService/ExtractMediaFiles

Request: anki.generic.String
Response: anki.generic.StringList

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-media extract-media-files [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extract-media-files
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.BackendMediaService/ExtractStaticMediaFiles

Request: anki.notetypes.NotetypeId
Response: anki.generic.StringList

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api backend-media extract-static-media-files [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extract-static-media-files
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.BackendMediaService/GetAbsoluteMediaPath

Request: anki.generic.String
Response: anki.generic.String

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-media get-absolute-media-path [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-absolute-media-path
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.BackendMediaService/RestoreTrash

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-media restore-trash [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for restore-trash
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.BackendMediaService/TrashMediaFiles

Request: anki.media.TrashMediaFilesRequest
Response: anki.generic.Empty

Request fields:
  fnames: repeated string

Usage:
  anki_as_code api backend-media trash-media-files [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for trash-media-files
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.notes.BackendNotesService

Usage:
  anki_as_code api backend-notes [command]

Available Commands:
  add-note                     /anki.notes.BackendNotesService/AddNote
  add-notes                    /anki.notes.BackendNotesService/AddNotes
  after-note-updates           /anki.notes.BackendNotesService/AfterNoteUpdates
  cards-of-note                /anki.notes.BackendNotesService/CardsOfNote
  cloze-numbers-in-note        /anki.notes.BackendNotesService/ClozeNumbersInNote
  default-deck-for-notetype    /anki.notes.BackendNotesService/DefaultDeckForNotetype
  defaults-for-adding          /anki.notes.BackendNotesService/DefaultsForAdding
  field-names-for-notes        /anki.notes.BackendNotesService/FieldNamesForNotes
  get-note                     /anki.notes.BackendNotesService/GetNote
  get-single-notetype-of-notes /anki.notes.BackendNotesService/GetSingleNotetypeOfNotes
  new-note                     /anki.notes.BackendNotesService/NewNote
  note-fields-check            /anki.notes.BackendNotesService/NoteFieldsCheck
  remove-notes                 /anki.notes.BackendNotesService/RemoveNotes
  update-notes                 /anki.notes.BackendNotesService/UpdateNotes

Flags:
  -h, --help   help for backend-notes

Use "anki_as_code api backend-notes [command] --help" for more information about a command.

/anki.notes.BackendNotesService/AddNote

Request: anki.notes.AddNoteRequest
Response: anki.notes.AddNoteResponse

Request fields:
  note: optional anki.notes.Note
  deck_id: optional int64

Usage:
  anki_as_code api backend-notes add-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/AddNotes

Request: anki.notes.AddNotesRequest
Response: anki.notes.AddNotesResponse

Request fields:
  requests: repeated anki.notes.AddNoteRequest

Usage:
  anki_as_code api backend-notes add-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/AfterNoteUpdates

Request: anki.notes.AfterNoteUpdatesRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  nids: repeated int64
  mark_notes_modified: optional bool
  generate_cards: optional bool

Usage:
  anki_as_code api backend-notes after-note-updates [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for after-note-updates
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/CardsOfNote

Request: anki.notes.NoteId
Response: anki.cards.CardIds

Request fields:
  nid: optional int64

Usage:
  anki_as_code api backend-notes cards-of-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for cards-of-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/ClozeNumbersInNote

Request: anki.notes.Note
Response: anki.notes.ClozeNumbersInNoteResponse

Request fields:
  id: optional int64
  guid: optional string
  notetype_id: optional int64
  mtime_secs: optional uint32
  usn: optional int32
  tags: repeated string
  fields: repeated string

Usage:
  anki_as_code api backend-notes cloze-numbers-in-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for cloze-numbers-in-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/DefaultDeckForNotetype

Request: anki.notetypes.NotetypeId
Response: anki.decks.DeckId

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api backend-notes default-deck-for-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for default-deck-for-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/DefaultsForAdding

Request: anki.notes.DefaultsForAddingRequest
Response: anki.notes.DeckAndNotetype

Request fields:
  home_deck_of_current_review_card: optional int64

Usage:
  anki_as_code api backend-notes defaults-for-adding [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for defaults-for-adding
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/FieldNamesForNotes

Request: anki.notes.FieldNamesForNotesRequest
Response: anki.notes.FieldNamesForNotesResponse

Request fields:
  nids: repeated int64

Usage:
  anki_as_code api backend-notes field-names-for-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for field-names-for-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/GetNote

Request: anki.notes.NoteId
Response: anki.notes.Note

Request fields:
  nid: optional int64

Usage:
  anki_as_code api backend-notes get-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/GetSingleNotetypeOfNotes

Request: anki.notes.NoteIds
Response: anki.notetypes.NotetypeId

Request fields:
  note_ids: repeated int64

Usage:
  anki_as_code api backend-notes get-single-notetype-of-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-single-notetype-of-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/NewNote

Request: anki.notetypes.NotetypeId
Response: anki.notes.Note

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api backend-notes new-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for new-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/NoteFieldsCheck

Request: anki.notes.Note
Response: anki.notes.NoteFieldsCheckResponse

Request fields:
  id: optional int64
  guid: optional string
  notetype_id: optional int64
  mtime_secs: optional uint32
  usn: optional int32
  tags: repeated string
  fields: repeated string

Usage:
  anki_as_code api backend-notes note-fields-check [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for note-fields-check
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/RemoveNotes

Request: anki.notes.RemoveNotesRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  note_ids: repeated int64
  card_ids: repeated int64

Usage:
  anki_as_code api backend-notes remove-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.BackendNotesService/UpdateNotes

Request: anki.notes.UpdateNotesRequest
Response: anki.collection.OpChanges

Request fields:
  notes: repeated anki.notes.Note
  skip_undo_entry: optional bool

Usage:
  anki_as_code api backend-notes update-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.notetypes.BackendNotetypesService

Usage:
  anki_as_code api backend-notetypes [command]

Available Commands:
  add-notetype                  /anki.notetypes.BackendNotetypesService/AddNotetype
  add-notetype-legacy           /anki.notetypes.BackendNotetypesService/AddNotetypeLegacy
  add-or-update-notetype        /anki.notetypes.BackendNotetypesService/AddOrUpdateNotetype
  change-notetype               /anki.notetypes.BackendNotetypesService/ChangeNotetype
  get-aux-notetype-config-key   /anki.notetypes.BackendNotetypesService/GetAuxNotetypeConfigKey
  get-aux-template-config-key   /anki.notetypes.BackendNotetypesService/GetAuxTemplateConfigKey
  get-change-notetype-info      /anki.notetypes.BackendNotetypesService/GetChangeNotetypeInfo
  get-cloze-field-ords          /anki.notetypes.BackendNotetypesService/GetClozeFieldOrds
  get-field-names               /anki.notetypes.BackendNotetypesService/GetFieldNames
  get-notetype                  /anki.notetypes.BackendNotetypesService/GetNotetype
  get-notetype-id-by-name       /anki.notetypes.BackendNotetypesService/GetNotetypeIdByName
  get-notetype-legacy           /anki.notetypes.BackendNotetypesService/GetNotetypeLegacy
  get-notetype-names            /anki.notetypes.BackendNotetypesService/GetNotetypeNames
  get-notetype-names-and-counts /anki.notetypes.BackendNotetypesService/GetNotetypeNamesAndCounts
  get-stock-notetype-legacy     /anki.notetypes.BackendNotetypesService/GetStockNotetypeLegacy
  remove-notetype               /anki.notetypes.BackendNotetypesService/RemoveNotetype
  restore-notetype-to-stock     /anki.notetypes.BackendNotetypesService/RestoreNotetypeToStock
  update-notetype               /anki.notetypes.BackendNotetypesService/UpdateNotetype
  update-notetype-legacy        /anki.notetypes.BackendNotetypesService/UpdateNotetypeLegacy

Flags:
  -h, --help   help for backend-notetypes

Use "anki_as_code api backend-notetypes [command] --help" for more information about a command.

/anki.notetypes.BackendNotetypesService/AddNotetype

Request: anki.notetypes.Notetype
Response: anki.collection.OpChangesWithId

Request fields:
  id: optional int64
  name: optional string
  mtime_secs: optional int64
  usn: optional sint32
  config: optional anki.notetypes.Notetype.Config
  fields: repeated anki.notetypes.Notetype.Field
  templates: repeated anki.notetypes.Notetype.Template

Usage:
  anki_as_code api backend-notetypes add-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/AddNotetypeLegacy

Request: anki.generic.Json
Response: anki.collection.OpChangesWithId

Request fields:
  json: optional bytes

Usage:
  anki_as_code api backend-notetypes add-notetype-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-notetype-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/AddOrUpdateNotetype

Request: anki.notetypes.AddOrUpdateNotetypeRequest
Response: anki.notetypes.NotetypeId

Request fields:
  json: optional bytes
  preserve_usn_and_mtime: optional bool
  skip_checks: optional bool

Usage:
  anki_as_code api backend-notetypes add-or-update-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-or-update-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/ChangeNotetype

Request: anki.notetypes.ChangeNotetypeRequest
Response: anki.collection.OpChanges

Request fields:
  note_ids: repeated int64
  new_fields: repeated int32
  new_templates: repeated int32
  old_notetype_id: optional int64
  new_notetype_id: optional int64
  current_schema: optional int64
  old_notetype_name: optional string
  is_cloze: optional bool

Usage:
  anki_as_code api backend-notetypes change-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for change-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetAuxNotetypeConfigKey

Request: anki.notetypes.GetAuxConfigKeyRequest
Response: anki.generic.String

Request fields:
  id: optional int64
  key: optional string

Usage:
  anki_as_code api backend-notetypes get-aux-notetype-config-key [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-aux-notetype-config-key
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetAuxTemplateConfigKey

Request: anki.notetypes.GetAuxTemplateConfigKeyRequest
Response: anki.generic.String

Request fields:
  notetype_id: optional int64
  card_ordinal: optional uint32
  key: optional string

Usage:
  anki_as_code api backend-notetypes get-aux-template-config-key [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-aux-template-config-key
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetChangeNotetypeInfo

Request: anki.notetypes.GetChangeNotetypeInfoRequest
Response: anki.notetypes.ChangeNotetypeInfo

Request fields:
  old_notetype_id: optional int64
  new_notetype_id: optional int64

Usage:
  anki_as_code api backend-notetypes get-change-notetype-info [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-change-notetype-info
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetClozeFieldOrds

Request: anki.notetypes.NotetypeId
Response: anki.notetypes.GetClozeFieldOrdsResponse

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api backend-notetypes get-cloze-field-ords [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-cloze-field-ords
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetFieldNames

Request: anki.notetypes.NotetypeId
Response: anki.generic.StringList

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api backend-notetypes get-field-names [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-field-names
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetNotetype

Request: anki.notetypes.NotetypeId
Response: anki.notetypes.Notetype

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api backend-notetypes get-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetNotetypeIdByName

Request: anki.generic.String
Response: anki.notetypes.NotetypeId

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-notetypes get-notetype-id-by-name [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-notetype-id-by-name
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetNotetypeLegacy

Request: anki.notetypes.NotetypeId
Response: anki.generic.Json

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api backend-notetypes get-notetype-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-notetype-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetNotetypeNames

Request: anki.generic.Empty
Response: anki.notetypes.NotetypeNames

Usage:
  anki_as_code api backend-notetypes get-notetype-names [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-notetype-names
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetNotetypeNamesAndCounts

Request: anki.generic.Empty
Response: anki.notetypes.NotetypeUseCounts

Usage:
  anki_as_code api backend-notetypes get-notetype-names-and-counts [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-notetype-names-and-counts
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/GetStockNotetypeLegacy

Request: anki.notetypes.StockNotetype
Response: anki.generic.Json

Request fields:
  kind: optional anki.notetypes.StockNotetype.Kind

Usage:
  anki_as_code api backend-notetypes get-stock-notetype-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-stock-notetype-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/RemoveNotetype

Request: anki.notetypes.NotetypeId
Response: anki.collection.OpChanges

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api backend-notetypes remove-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/RestoreNotetypeToStock

Request: anki.notetypes.RestoreNotetypeToStockRequest
Response: anki.collection.OpChanges

Request fields:
  notetype_id: optional anki.notetypes.NotetypeId
  force_kind: optional anki.notetypes.StockNotetype.Kind

Usage:
  anki_as_code api backend-notetypes restore-notetype-to-stock [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for restore-notetype-to-stock
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/UpdateNotetype

Request: anki.notetypes.Notetype
Response: anki.collection.OpChanges

Request fields:
  id: optional int64
  name: optional string
  mtime_secs: optional int64
  usn: optional sint32
  config: optional anki.notetypes.Notetype.Config
  fields: repeated anki.notetypes.Notetype.Field
  templates: repeated anki.notetypes.Notetype.Template

Usage:
  anki_as_code api backend-notetypes update-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.BackendNotetypesService/UpdateNotetypeLegacy

Request: anki.notetypes.UpdateNotetypeLegacyRequest
Response: anki.collection.OpChanges

Request fields:
  json: optional bytes
  skip_checks: optional bool

Usage:
  anki_as_code api backend-notetypes update-notetype-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-notetype-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.scheduler.BackendSchedulerService

Usage:
  anki_as_code api backend-scheduler [command]

Available Commands:
  answer-card                        /anki.scheduler.BackendSchedulerService/AnswerCard
  bury-or-suspend-cards              /anki.scheduler.BackendSchedulerService/BuryOrSuspendCards
  compute-fsrs-params                /anki.scheduler.BackendSchedulerService/ComputeFsrsParams
  compute-fsrs-params-from-items     /anki.scheduler.BackendSchedulerService/ComputeFsrsParamsFromItems
  compute-memory-state               /anki.scheduler.BackendSchedulerService/ComputeMemoryState
  compute-optimal-retention          /anki.scheduler.BackendSchedulerService/ComputeOptimalRetention
  congrats-info                      /anki.scheduler.BackendSchedulerService/CongratsInfo
  counts-for-deck-today              /anki.scheduler.BackendSchedulerService/CountsForDeckToday
  custom-study                       /anki.scheduler.BackendSchedulerService/CustomStudy
  custom-study-defaults              /anki.scheduler.BackendSchedulerService/CustomStudyDefaults
  describe-next-states               /anki.scheduler.BackendSchedulerService/DescribeNextStates
  empty-filtered-deck                /anki.scheduler.BackendSchedulerService/EmptyFilteredDeck
  evaluate-params                    /anki.scheduler.BackendSchedulerService/EvaluateParams
  evaluate-params-legacy             /anki.scheduler.BackendSchedulerService/EvaluateParamsLegacy
  export-dataset                     /anki.scheduler.BackendSchedulerService/ExportDataset
  extend-limits                      /anki.scheduler.BackendSchedulerService/ExtendLimits
  fsrs-benchmark                     /anki.scheduler.BackendSchedulerService/FsrsBenchmark
  fuzz-delta                         /anki.scheduler.BackendSchedulerService/FuzzDelta
  get-optimal-retention-parameters   /anki.scheduler.BackendSchedulerService/GetOptimalRetentionParameters
  get-queued-cards                   /anki.scheduler.BackendSchedulerService/GetQueuedCards
  get-scheduling-states              /anki.scheduler.BackendSchedulerService/GetSchedulingStates
  grade-now                          /anki.scheduler.BackendSchedulerService/GradeNow
  rebuild-filtered-deck              /anki.scheduler.BackendSchedulerService/RebuildFilteredDeck
  reposition-defaults                /anki.scheduler.BackendSchedulerService/RepositionDefaults
  restore-buried-and-suspended-cards /anki.scheduler.BackendSchedulerService/RestoreBuriedAndSuspendedCards
  sched-timing-today                 /anki.scheduler.BackendSchedulerService/SchedTimingToday
  schedule-cards-as-new              /anki.scheduler.BackendSchedulerService/ScheduleCardsAsNew
  schedule-cards-as-new-defaults     /anki.scheduler.BackendSchedulerService/ScheduleCardsAsNewDefaults
  set-due-date                       /anki.scheduler.BackendSchedulerService/SetDueDate
  simulate-fsrs-review               /anki.scheduler.BackendSchedulerService/SimulateFsrsReview
  simulate-fsrs-workload             /anki.scheduler.BackendSchedulerService/SimulateFsrsWorkload
  sort-cards                         /anki.scheduler.BackendSchedulerService/SortCards
  sort-deck                          /anki.scheduler.BackendSchedulerService/SortDeck
  state-is-leech                     /anki.scheduler.BackendSchedulerService/StateIsLeech
  studied-today                      /anki.scheduler.BackendSchedulerService/StudiedToday
  studied-today-message              /anki.scheduler.BackendSchedulerService/StudiedTodayMessage
  unbury-deck                        /anki.scheduler.BackendSchedulerService/UnburyDeck
  update-stats                       /anki.scheduler.BackendSchedulerService/UpdateStats
  upgrade-scheduler                  /anki.scheduler.BackendSchedulerService/UpgradeScheduler

Flags:
  -h, --help   help for backend-scheduler

Use "anki_as_code api backend-scheduler [command] --help" for more information about a command.

/anki.scheduler.BackendSchedulerService/AnswerCard

Request: anki.scheduler.CardAnswer
Response: anki.collection.OpChanges

Request fields:
  card_id: optional int64
  current_state: optional anki.scheduler.SchedulingState
  new_state: optional anki.scheduler.SchedulingState
  rating: optional anki.scheduler.CardAnswer.Rating
  answered_at_millis: optional int64
  milliseconds_taken: optional uint32

Usage:
  anki_as_code api backend-scheduler answer-card [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for answer-card
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/BuryOrSuspendCards

Request: anki.scheduler.BuryOrSuspendCardsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  card_ids: repeated int64
  note_ids: repeated int64
  mode: optional anki.scheduler.BuryOrSuspendCardsRequest.Mode

Usage:
  anki_as_code api backend-scheduler bury-or-suspend-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for bury-or-suspend-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/ComputeFsrsParams

Request: anki.scheduler.ComputeFsrsParamsRequest
Response: anki.scheduler.ComputeFsrsParamsResponse

Request fields:
  search: optional string
  current_params: repeated float
  ignore_revlogs_before_ms: optional int64
  num_of_relearning_steps: optional uint32
  health_check: optional bool

Usage:
  anki_as_code api backend-scheduler compute-fsrs-params [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for compute-fsrs-params
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/ComputeFsrsParamsFromItems

Request: anki.scheduler.ComputeFsrsParamsFromItemsRequest
Response: anki.scheduler.ComputeFsrsParamsResponse

Request fields:
  items: repeated anki.scheduler.FsrsItem

Usage:
  anki_as_code api backend-scheduler compute-fsrs-params-from-items [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for compute-fsrs-params-from-items
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/ComputeMemoryState

Request: anki.cards.CardId
Response: anki.scheduler.ComputeMemoryStateResponse

Request fields:
  cid: optional int64

Usage:
  anki_as_code api backend-scheduler compute-memory-state [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for compute-memory-state
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/ComputeOptimalRetention

Request: anki.scheduler.SimulateFsrsReviewRequest
Response: anki.scheduler.ComputeOptimalRetentionResponse

Request fields:
  params: repeated float
  desired_retention: optional float
  deck_size: optional uint32
  days_to_simulate: optional uint32
  new_limit: optional uint32
  review_limit: optional uint32
  max_interval: optional uint32
  search: optional string
  new_cards_ignore_review_limit: optional bool
  easy_days_percentages: repeated float
  review_order: optional anki.deck_config.DeckConfig.Config.ReviewCardOrder
  suspend_after_lapse_count: optional uint32
  historical_retention: optional float
  learning_step_count: optional uint32
  relearning_step_count: optional uint32

Usage:
  anki_as_code api backend-scheduler compute-optimal-retention [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for compute-optimal-retention
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/CongratsInfo

Request: anki.generic.Empty
Response: anki.scheduler.CongratsInfoResponse

Usage:
  anki_as_code api backend-scheduler congrats-info [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for congrats-info
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/CountsForDeckToday

Request: anki.decks.DeckId
Response: anki.scheduler.CountsForDeckTodayResponse

Request fields:
  did: optional int64

Usage:
  anki_as_code api backend-scheduler counts-for-deck-today [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for counts-for-deck-today
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/CustomStudy

Request: anki.scheduler.CustomStudyRequest
Response: anki.collection.OpChanges

Request fields:
  deck_id: optional int64
  new_limit_delta: optional int32
  review_limit_delta: optional int32
  forgot_days: optional uint32
  review_ahead_days: optional uint32
  preview_days: optional uint32
  cram: optional anki.scheduler.CustomStudyRequest.Cram

Usage:
  anki_as_code api backend-scheduler custom-study [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for custom-study
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/CustomStudyDefaults

Request: anki.scheduler.CustomStudyDefaultsRequest
Response: anki.scheduler.CustomStudyDefaultsResponse

Request fields:
  deck_id: optional int64

Usage:
  anki_as_code api backend-scheduler custom-study-defaults [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for custom-study-defaults
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/DescribeNextStates

Request: anki.scheduler.SchedulingStates
Response: anki.generic.StringList

Request fields:
  current: optional anki.scheduler.SchedulingState
  again: optional anki.scheduler.SchedulingState
  hard: optional anki.scheduler.SchedulingState
  good: optional anki.scheduler.SchedulingState
  easy: optional anki.scheduler.SchedulingState

Usage:
  anki_as_code api backend-scheduler describe-next-states [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for describe-next-states
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/EmptyFilteredDeck

Request: anki.decks.DeckId
Response: anki.collection.OpChanges

Request fields:
  did: optional int64

Usage:
  anki_as_code api backend-scheduler empty-filtered-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for empty-filtered-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/EvaluateParams

Request: anki.scheduler.EvaluateParamsRequest
Response: anki.scheduler.EvaluateParamsResponse

Request fields:
  search: optional string
  ignore_revlogs_before_ms: optional int64
  num_of_relearning_steps: optional uint32

Usage:
  anki_as_code api backend-scheduler evaluate-params [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for evaluate-params
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/EvaluateParamsLegacy

Request: anki.scheduler.EvaluateParamsLegacyRequest
Response: anki.scheduler.EvaluateParamsResponse

Request fields:
  params: repeated float
  search: optional string
  ignore_revlogs_before_ms: optional int64

Usage:
  anki_as_code api backend-scheduler evaluate-params-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for evaluate-params-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/ExportDataset

Request: anki.scheduler.ExportDatasetRequest
Response: anki.generic.Empty

Request fields:
  min_entries: optional uint32
  target_path: optional string

Usage:
  anki_as_code api backend-scheduler export-dataset [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for export-dataset
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/ExtendLimits

Request: anki.scheduler.ExtendLimitsRequest
Response: anki.generic.Empty

Request fields:
  deck_id: optional int64
  new_delta: optional int32
  review_delta: optional int32

Usage:
  anki_as_code api backend-scheduler extend-limits [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extend-limits
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/FsrsBenchmark

Request: anki.scheduler.FsrsBenchmarkRequest
Response: anki.scheduler.FsrsBenchmarkResponse

Request fields:
  train_set: repeated anki.scheduler.FsrsItem

Usage:
  anki_as_code api backend-scheduler fsrs-benchmark [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for fsrs-benchmark
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/FuzzDelta

Request: anki.scheduler.FuzzDeltaRequest
Response: anki.scheduler.FuzzDeltaResponse

Request fields:
  card_id: optional int64
  interval: optional uint32

Usage:
  anki_as_code api backend-scheduler fuzz-delta [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for fuzz-delta
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/GetOptimalRetentionParameters

Request: anki.scheduler.GetOptimalRetentionParametersRequest
Response: anki.scheduler.GetOptimalRetentionParametersResponse

Request fields:
  search: optional string

Usage:
  anki_as_code api backend-scheduler get-optimal-retention-parameters [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-optimal-retention-parameters
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/GetQueuedCards

Request: anki.scheduler.GetQueuedCardsRequest
Response: anki.scheduler.QueuedCards

Request fields:
  fetch_limit: optional uint32
  intraday_learning_only: optional bool

Usage:
  anki_as_code api backend-scheduler get-queued-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-queued-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/GetSchedulingStates

Request: anki.cards.CardId
Response: anki.scheduler.SchedulingStates

Request fields:
  cid: optional int64

Usage:
  anki_as_code api backend-scheduler get-scheduling-states [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-scheduling-states
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/GradeNow

Request: anki.scheduler.GradeNowRequest
Response: anki.collection.OpChanges

Request fields:
  card_ids: repeated int64
  rating: optional anki.scheduler.CardAnswer.Rating

Usage:
  anki_as_code api backend-scheduler grade-now [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for grade-now
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/RebuildFilteredDeck

Request: anki.decks.DeckId
Response: anki.collection.OpChangesWithCount

Request fields:
  did: optional int64

Usage:
  anki_as_code api backend-scheduler rebuild-filtered-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for rebuild-filtered-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/RepositionDefaults

Request: anki.generic.Empty
Response: anki.scheduler.RepositionDefaultsResponse

Usage:
  anki_as_code api backend-scheduler reposition-defaults [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for reposition-defaults
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/RestoreBuriedAndSuspendedCards

Request: anki.cards.CardIds
Response: anki.collection.OpChanges

Request fields:
  cids: repeated int64

Usage:
  anki_as_code api backend-scheduler restore-buried-and-suspended-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for restore-buried-and-suspended-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/SchedTimingToday

Request: anki.generic.Empty
Response: anki.scheduler.SchedTimingTodayResponse

Usage:
  anki_as_code api backend-scheduler sched-timing-today [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sched-timing-today
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/ScheduleCardsAsNew

Request: anki.scheduler.ScheduleCardsAsNewRequest
Response: anki.collection.OpChanges

Request fields:
  card_ids: repeated int64
  log: optional bool
  restore_position: optional bool
  reset_counts: optional bool
  context: optional anki.scheduler.ScheduleCardsAsNewRequest.Context

Usage:
  anki_as_code api backend-scheduler schedule-cards-as-new [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for schedule-cards-as-new
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/ScheduleCardsAsNewDefaults

Request: anki.scheduler.ScheduleCardsAsNewDefaultsRequest
Response: anki.scheduler.ScheduleCardsAsNewDefaultsResponse

Request fields:
  context: optional anki.scheduler.ScheduleCardsAsNewRequest.Context

Usage:
  anki_as_code api backend-scheduler schedule-cards-as-new-defaults [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for schedule-cards-as-new-defaults
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/SetDueDate

Request: anki.scheduler.SetDueDateRequest
Response: anki.collection.OpChanges

Request fields:
  card_ids: repeated int64
  days: optional string
  config_key: optional anki.config.OptionalStringConfigKey

Usage:
  anki_as_code api backend-scheduler set-due-date [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-due-date
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/SimulateFsrsReview

Request: anki.scheduler.SimulateFsrsReviewRequest
Response: anki.scheduler.SimulateFsrsReviewResponse

Request fields:
  params: repeated float
  desired_retention: optional float
  deck_size: optional uint32
  days_to_simulate: optional uint32
  new_limit: optional uint32
  review_limit: optional uint32
  max_interval: optional uint32
  search: optional string
  new_cards_ignore_review_limit: optional bool
  easy_days_percentages: repeated float
  review_order: optional anki.deck_config.DeckConfig.Config.ReviewCardOrder
  suspend_after_lapse_count: optional uint32
  historical_retention: optional float
  learning_step_count: optional uint32
  relearning_step_count: optional uint32

Usage:
  anki_as_code api backend-scheduler simulate-fsrs-review [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for simulate-fsrs-review
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/SimulateFsrsWorkload

Request: anki.scheduler.SimulateFsrsReviewRequest
Response: anki.scheduler.SimulateFsrsWorkloadResponse

Request fields:
  params: repeated float
  desired_retention: optional float
  deck_size: optional uint32
  days_to_simulate: optional uint32
  new_limit: optional uint32
  review_limit: optional uint32
  max_interval: optional uint32
  search: optional string
  new_cards_ignore_review_limit: optional bool
  easy_days_percentages: repeated float
  review_order: optional anki.deck_config.DeckConfig.Config.ReviewCardOrder
  suspend_after_lapse_count: optional uint32
  historical_retention: optional float
  learning_step_count: optional uint32
  relearning_step_count: optional uint32

Usage:
  anki_as_code api backend-scheduler simulate-fsrs-workload [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for simulate-fsrs-workload
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/SortCards

Request: anki.scheduler.SortCardsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  card_ids: repeated int64
  starting_from: optional uint32
  step_size: optional uint32
  randomize: optional bool
  shift_existing: optional bool

Usage:
  anki_as_code api backend-scheduler sort-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sort-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/SortDeck

Request: anki.scheduler.SortDeckRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  deck_id: optional int64
  randomize: optional bool

Usage:
  anki_as_code api backend-scheduler sort-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sort-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/StateIsLeech

Request: anki.scheduler.SchedulingState
Response: anki.generic.Bool

Request fields:
  normal: optional anki.scheduler.SchedulingState.Normal
  filtered: optional anki.scheduler.SchedulingState.Filtered
  custom_data: optional string

Usage:
  anki_as_code api backend-scheduler state-is-leech [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for state-is-leech
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/StudiedToday

Request: anki.generic.Empty
Response: anki.generic.String

Usage:
  anki_as_code api backend-scheduler studied-today [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for studied-today
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/StudiedTodayMessage

Request: anki.scheduler.StudiedTodayMessageRequest
Response: anki.generic.String

Request fields:
  cards: optional uint32
  seconds: optional double

Usage:
  anki_as_code api backend-scheduler studied-today-message [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for studied-today-message
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/UnburyDeck

Request: anki.scheduler.UnburyDeckRequest
Response: anki.collection.OpChanges

Request fields:
  deck_id: optional int64
  mode: optional anki.scheduler.UnburyDeckRequest.Mode

Usage:
  anki_as_code api backend-scheduler unbury-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for unbury-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/UpdateStats

Request: anki.scheduler.UpdateStatsRequest
Response: anki.generic.Empty

Request fields:
  deck_id: optional int64
  new_delta: optional int32
  review_delta: optional int32
  millisecond_delta: optional int32

Usage:
  anki_as_code api backend-scheduler update-stats [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-stats
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.BackendSchedulerService/UpgradeScheduler

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-scheduler upgrade-scheduler [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for upgrade-scheduler
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.search.BackendSearchService

Usage:
  anki_as_code api backend-search [command]

Available Commands:
  all-browser-columns        /anki.search.BackendSearchService/AllBrowserColumns
  browser-row-for-id         /anki.search.BackendSearchService/BrowserRowForId
  build-search-string        /anki.search.BackendSearchService/BuildSearchString
  find-and-replace           /anki.search.BackendSearchService/FindAndReplace
  join-search-nodes          /anki.search.BackendSearchService/JoinSearchNodes
  replace-search-node        /anki.search.BackendSearchService/ReplaceSearchNode
  search-cards               /anki.search.BackendSearchService/SearchCards
  search-notes               /anki.search.BackendSearchService/SearchNotes
  set-active-browser-columns /anki.search.BackendSearchService/SetActiveBrowserColumns

Flags:
  -h, --help   help for backend-search

Use "anki_as_code api backend-search [command] --help" for more information about a command.

/anki.search.BackendSearchService/AllBrowserColumns

Request: anki.generic.Empty
Response: anki.search.BrowserColumns

Usage:
  anki_as_code api backend-search all-browser-columns [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for all-browser-columns
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.BackendSearchService/BrowserRowForId

Request: anki.generic.Int64
Response: anki.search.BrowserRow

Request fields:
  val: optional int64

Usage:
  anki_as_code api backend-search browser-row-for-id [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for browser-row-for-id
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.BackendSearchService/BuildSearchString

Request: anki.search.SearchNode
Response: anki.generic.String

Request fields:
  group: optional anki.search.SearchNode.Group
  negated: optional anki.search.SearchNode
  parsable_text: optional string
  template: optional uint32
  nid: optional int64
  dupe: optional anki.search.SearchNode.Dupe
  field_name: optional string
  rated: optional anki.search.SearchNode.Rated
  added_in_days: optional uint32
  due_in_days: optional int32
  flag: optional anki.search.SearchNode.Flag
  card_state: optional anki.search.SearchNode.CardState
  nids: optional anki.search.SearchNode.IdList
  edited_in_days: optional uint32
  deck: optional string
  due_on_day: optional int32
  tag: optional string
  note: optional string
  introduced_in_days: optional uint32
  field: optional anki.search.SearchNode.Field
  literal_text: optional string

Usage:
  anki_as_code api backend-search build-search-string [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for build-search-string
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.BackendSearchService/FindAndReplace

Request: anki.search.FindAndReplaceRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  nids: repeated int64
  search: optional string
  replacement: optional string
  regex: optional bool
  match_case: optional bool
  field_name: optional string

Usage:
  anki_as_code api backend-search find-and-replace [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for find-and-replace
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.BackendSearchService/JoinSearchNodes

Request: anki.search.JoinSearchNodesRequest
Response: anki.generic.String

Request fields:
  joiner: optional anki.search.SearchNode.Group.Joiner
  existing_node: optional anki.search.SearchNode
  additional_node: optional anki.search.SearchNode

Usage:
  anki_as_code api backend-search join-search-nodes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for join-search-nodes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.BackendSearchService/ReplaceSearchNode

Request: anki.search.ReplaceSearchNodeRequest
Response: anki.generic.String

Request fields:
  existing_node: optional anki.search.SearchNode
  replacement_node: optional anki.search.SearchNode

Usage:
  anki_as_code api backend-search replace-search-node [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for replace-search-node
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.BackendSearchService/SearchCards

Request: anki.search.SearchRequest
Response: anki.search.SearchResponse

Request fields:
  search: optional string
  order: optional anki.search.SortOrder

Usage:
  anki_as_code api backend-search search-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for search-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.BackendSearchService/SearchNotes

Request: anki.search.SearchRequest
Response: anki.search.SearchResponse

Request fields:
  search: optional string
  order: optional anki.search.SortOrder

Usage:
  anki_as_code api backend-search search-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for search-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.BackendSearchService/SetActiveBrowserColumns

Request: anki.generic.StringList
Response: anki.generic.Empty

Request fields:
  vals: repeated string

Usage:
  anki_as_code api backend-search set-active-browser-columns [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-active-browser-columns
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.stats.BackendStatsService

Usage:
  anki_as_code api backend-stats [command]

Available Commands:
  card-stats            /anki.stats.BackendStatsService/CardStats
  get-graph-preferences /anki.stats.BackendStatsService/GetGraphPreferences
  get-review-logs       /anki.stats.BackendStatsService/GetReviewLogs
  graphs                /anki.stats.BackendStatsService/Graphs
  set-graph-preferences /anki.stats.BackendStatsService/SetGraphPreferences

Flags:
  -h, --help   help for backend-stats

Use "anki_as_code api backend-stats [command] --help" for more information about a command.

/anki.stats.BackendStatsService/CardStats

Request: anki.cards.CardId
Response: anki.stats.CardStatsResponse

Request fields:
  cid: optional int64

Usage:
  anki_as_code api backend-stats card-stats [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for card-stats
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.stats.BackendStatsService/GetGraphPreferences

Request: anki.generic.Empty
Response: anki.stats.GraphPreferences

Usage:
  anki_as_code api backend-stats get-graph-preferences [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-graph-preferences
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.stats.BackendStatsService/GetReviewLogs

Request: anki.cards.CardId
Response: anki.stats.ReviewLogs

Request fields:
  cid: optional int64

Usage:
  anki_as_code api backend-stats get-review-logs [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-review-logs
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.stats.BackendStatsService/Graphs

Request: anki.stats.GraphsRequest
Response: anki.stats.GraphsResponse

Request fields:
  search: optional string
  days: optional uint32

Usage:
  anki_as_code api backend-stats graphs [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for graphs
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.stats.BackendStatsService/SetGraphPreferences

Request: anki.stats.GraphPreferences
Response: anki.generic.Empty

Request fields:
  calendar_first_day_of_week: optional anki.stats.GraphPreferences.Weekday
  card_counts_separate_inactive: optional bool
  browser_links_supported: optional bool
  future_due_show_backlog: optional bool

Usage:
  anki_as_code api backend-stats set-graph-preferences [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-graph-preferences
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.sync.BackendSyncService

Usage:
  anki_as_code api backend-sync [command]

Available Commands:
  abort-media-sync        /anki.sync.BackendSyncService/AbortMediaSync
  abort-sync              /anki.sync.BackendSyncService/AbortSync
  full-upload-or-download /anki.sync.BackendSyncService/FullUploadOrDownload
  media-sync-status       /anki.sync.BackendSyncService/MediaSyncStatus
  set-custom-certificate  /anki.sync.BackendSyncService/SetCustomCertificate
  sync-collection         /anki.sync.BackendSyncService/SyncCollection
  sync-login              /anki.sync.BackendSyncService/SyncLogin
  sync-media              /anki.sync.BackendSyncService/SyncMedia
  sync-status             /anki.sync.BackendSyncService/SyncStatus

Flags:
  -h, --help   help for backend-sync

Use "anki_as_code api backend-sync [command] --help" for more information about a command.

/anki.sync.BackendSyncService/AbortMediaSync

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-sync abort-media-sync [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for abort-media-sync
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.sync.BackendSyncService/AbortSync

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api backend-sync abort-sync [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for abort-sync
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.sync.BackendSyncService/FullUploadOrDownload

Request: anki.sync.FullUploadOrDownloadRequest
Response: anki.generic.Empty

Request fields:
  auth: optional anki.sync.SyncAuth
  upload: optional bool
  server_usn: optional int32

Usage:
  anki_as_code api backend-sync full-upload-or-download [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for full-upload-or-download
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.sync.BackendSyncService/MediaSyncStatus

Request: anki.generic.Empty
Response: anki.sync.MediaSyncStatusResponse

Usage:
  anki_as_code api backend-sync media-sync-status [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for media-sync-status
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.sync.BackendSyncService/SetCustomCertificate

Request: anki.generic.String
Response: anki.generic.Bool

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-sync set-custom-certificate [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-custom-certificate
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.sync.BackendSyncService/SyncCollection

Request: anki.sync.SyncCollectionRequest
Response: anki.sync.SyncCollectionResponse

Request fields:
  auth: optional anki.sync.SyncAuth
  sync_media: optional bool

Usage:
  anki_as_code api backend-sync sync-collection [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sync-collection
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.sync.BackendSyncService/SyncLogin

Request: anki.sync.SyncLoginRequest
Response: anki.sync.SyncAuth

Request fields:
  username: optional string
  password: optional string
  endpoint: optional string

Usage:
  anki_as_code api backend-sync sync-login [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sync-login
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.sync.BackendSyncService/SyncMedia

Request: anki.sync.SyncAuth
Response: anki.generic.Empty

Request fields:
  hkey: optional string
  endpoint: optional string
  io_timeout_secs: optional uint32

Usage:
  anki_as_code api backend-sync sync-media [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sync-media
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.sync.BackendSyncService/SyncStatus

Request: anki.sync.SyncAuth
Response: anki.sync.SyncStatusResponse

Request fields:
  hkey: optional string
  endpoint: optional string
  io_timeout_secs: optional uint32

Usage:
  anki_as_code api backend-sync sync-status [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sync-status
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.tags.BackendTagsService

Usage:
  anki_as_code api backend-tags [command]

Available Commands:
  add-note-tags        /anki.tags.BackendTagsService/AddNoteTags
  all-tags             /anki.tags.BackendTagsService/AllTags
  clear-unused-tags    /anki.tags.BackendTagsService/ClearUnusedTags
  complete-tag         /anki.tags.BackendTagsService/CompleteTag
  find-and-replace-tag /anki.tags.BackendTagsService/FindAndReplaceTag
  remove-note-tags     /anki.tags.BackendTagsService/RemoveNoteTags
  remove-tags          /anki.tags.BackendTagsService/RemoveTags
  rename-tags          /anki.tags.BackendTagsService/RenameTags
  reparent-tags        /anki.tags.BackendTagsService/ReparentTags
  set-tag-collapsed    /anki.tags.BackendTagsService/SetTagCollapsed
  tag-tree             /anki.tags.BackendTagsService/TagTree

Flags:
  -h, --help   help for backend-tags

Use "anki_as_code api backend-tags [command] --help" for more information about a command.

/anki.tags.BackendTagsService/AddNoteTags

Request: anki.tags.NoteIdsAndTagsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  note_ids: repeated int64
  tags: optional string

Usage:
  anki_as_code api backend-tags add-note-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-note-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.BackendTagsService/AllTags

Request: anki.generic.Empty
Response: anki.generic.StringList

Usage:
  anki_as_code api backend-tags all-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for all-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.BackendTagsService/ClearUnusedTags

Request: anki.generic.Empty
Response: anki.collection.OpChangesWithCount

Usage:
  anki_as_code api backend-tags clear-unused-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for clear-unused-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.BackendTagsService/CompleteTag

Request: anki.tags.CompleteTagRequest
Response: anki.tags.CompleteTagResponse

Request fields:
  input: optional string
  match_limit: optional uint32

Usage:
  anki_as_code api backend-tags complete-tag [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for complete-tag
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.BackendTagsService/FindAndReplaceTag

Request: anki.tags.FindAndReplaceTagRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  note_ids: repeated int64
  search: optional string
  replacement: optional string
  regex: optional bool
  match_case: optional bool

Usage:
  anki_as_code api backend-tags find-and-replace-tag [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for find-and-replace-tag
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.BackendTagsService/RemoveNoteTags

Request: anki.tags.NoteIdsAndTagsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  note_ids: repeated int64
  tags: optional string

Usage:
  anki_as_code api backend-tags remove-note-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-note-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.BackendTagsService/RemoveTags

Request: anki.generic.String
Response: anki.collection.OpChangesWithCount

Request fields:
  val: optional string

Usage:
  anki_as_code api backend-tags remove-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.BackendTagsService/RenameTags

Request: anki.tags.RenameTagsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  current_prefix: optional string
  new_prefix: optional string

Usage:
  anki_as_code api backend-tags rename-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for rename-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.BackendTagsService/ReparentTags

Request: anki.tags.ReparentTagsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  tags: repeated string
  new_parent: optional string

Usage:
  anki_as_code api backend-tags reparent-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for reparent-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.BackendTagsService/SetTagCollapsed

Request: anki.tags.SetTagCollapsedRequest
Response: anki.collection.OpChanges

Request fields:
  name: optional string
  collapsed: optional bool

Usage:
  anki_as_code api backend-tags set-tag-collapsed [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-tag-collapsed
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.BackendTagsService/TagTree

Request: anki.generic.Empty
Response: anki.tags.TagTreeNode

Usage:
  anki_as_code api backend-tags tag-tree [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for tag-tree
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.card_rendering.CardRenderingService

Usage:
  anki_as_code api card-rendering [command]

Available Commands:
  compare-answer                 /anki.card_rendering.CardRenderingService/CompareAnswer
  decode-iri-paths               /anki.card_rendering.CardRenderingService/DecodeIriPaths
  encode-iri-paths               /anki.card_rendering.CardRenderingService/EncodeIriPaths
  extract-av-tags                /anki.card_rendering.CardRenderingService/ExtractAvTags
  extract-cloze-for-typing       /anki.card_rendering.CardRenderingService/ExtractClozeForTyping
  extract-latex                  /anki.card_rendering.CardRenderingService/ExtractLatex
  get-empty-cards                /anki.card_rendering.CardRenderingService/GetEmptyCards
  html-to-text-line              /anki.card_rendering.CardRenderingService/HtmlToTextLine
  render-existing-card           /anki.card_rendering.CardRenderingService/RenderExistingCard
  render-markdown                /anki.card_rendering.CardRenderingService/RenderMarkdown
  render-uncommitted-card        /anki.card_rendering.CardRenderingService/RenderUncommittedCard
  render-uncommitted-card-legacy /anki.card_rendering.CardRenderingService/RenderUncommittedCardLegacy
  strip-av-tags                  /anki.card_rendering.CardRenderingService/StripAvTags
  strip-html                     /anki.card_rendering.CardRenderingService/StripHtml

Flags:
  -h, --help   help for card-rendering

Use "anki_as_code api card-rendering [command] --help" for more information about a command.

/anki.card_rendering.CardRenderingService/CompareAnswer

Request: anki.card_rendering.CompareAnswerRequest
Response: anki.generic.String

Request fields:
  expected: optional string
  provided: optional string
  combining: optional bool

Usage:
  anki_as_code api card-rendering compare-answer [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for compare-answer
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/DecodeIriPaths

Request: anki.generic.String
Response: anki.generic.String

Request fields:
  val: optional string

Usage:
  anki_as_code api card-rendering decode-iri-paths [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for decode-iri-paths
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/EncodeIriPaths

Request: anki.generic.String
Response: anki.generic.String

Request fields:
  val: optional string

Usage:
  anki_as_code api card-rendering encode-iri-paths [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for encode-iri-paths
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/ExtractAvTags

Request: anki.card_rendering.ExtractAvTagsRequest
Response: anki.card_rendering.ExtractAvTagsResponse

Request fields:
  text: optional string
  question_side: optional bool

Usage:
  anki_as_code api card-rendering extract-av-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extract-av-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/ExtractClozeForTyping

Request: anki.card_rendering.ExtractClozeForTypingRequest
Response: anki.generic.String

Request fields:
  text: optional string
  ordinal: optional uint32

Usage:
  anki_as_code api card-rendering extract-cloze-for-typing [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extract-cloze-for-typing
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/ExtractLatex

Request: anki.card_rendering.ExtractLatexRequest
Response: anki.card_rendering.ExtractLatexResponse

Request fields:
  text: optional string
  svg: optional bool
  expand_clozes: optional bool

Usage:
  anki_as_code api card-rendering extract-latex [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extract-latex
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/GetEmptyCards

Request: anki.generic.Empty
Response: anki.card_rendering.EmptyCardsReport

Usage:
  anki_as_code api card-rendering get-empty-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-empty-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki_as_code api card-rendering html-to-text-line

/anki.card_rendering.CardRenderingService/HtmlToTextLine

Request: anki.card_rendering.HtmlToTextLineRequest
Response: anki.generic.String

Request fields:
  text: optional string
  preserve_media_filenames: optional bool

Usage:
  anki_as_code api card-rendering html-to-text-line [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for html-to-text-line
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/RenderExistingCard

Request: anki.card_rendering.RenderExistingCardRequest
Response: anki.card_rendering.RenderCardResponse

Request fields:
  card_id: optional int64
  browser: optional bool
  partial_render: optional bool

Usage:
  anki_as_code api card-rendering render-existing-card [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for render-existing-card
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/RenderMarkdown

Request: anki.card_rendering.RenderMarkdownRequest
Response: anki.generic.String

Request fields:
  markdown: optional string
  sanitize: optional bool

Usage:
  anki_as_code api card-rendering render-markdown [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for render-markdown
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/RenderUncommittedCard

Request: anki.card_rendering.RenderUncommittedCardRequest
Response: anki.card_rendering.RenderCardResponse

Request fields:
  note: optional anki.notes.Note
  card_ord: optional uint32
  template: optional anki.notetypes.Notetype.Template
  fill_empty: optional bool
  partial_render: optional bool

Usage:
  anki_as_code api card-rendering render-uncommitted-card [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for render-uncommitted-card
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/RenderUncommittedCardLegacy

Request: anki.card_rendering.RenderUncommittedCardLegacyRequest
Response: anki.card_rendering.RenderCardResponse

Request fields:
  note: optional anki.notes.Note
  card_ord: optional uint32
  template: optional bytes
  fill_empty: optional bool
  partial_render: optional bool

Usage:
  anki_as_code api card-rendering render-uncommitted-card-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for render-uncommitted-card-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/StripAvTags

Request: anki.generic.String
Response: anki.generic.String

Request fields:
  val: optional string

Usage:
  anki_as_code api card-rendering strip-av-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for strip-av-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.card_rendering.CardRenderingService/StripHtml

Request: anki.card_rendering.StripHtmlRequest
Response: anki.generic.String

Request fields:
  text: optional string
  mode: optional anki.card_rendering.StripHtmlRequest.Mode

Usage:
  anki_as_code api card-rendering strip-html [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for strip-html
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.cards.CardsService

Usage:
  anki_as_code api cards [command]

Available Commands:
  get-card     /anki.cards.CardsService/GetCard
  remove-cards /anki.cards.CardsService/RemoveCards
  set-deck     /anki.cards.CardsService/SetDeck
  set-flag     /anki.cards.CardsService/SetFlag
  update-cards /anki.cards.CardsService/UpdateCards

Flags:
  -h, --help   help for cards

Use "anki_as_code api cards [command] --help" for more information about a command.

/anki.cards.CardsService/GetCard

Request: anki.cards.CardId
Response: anki.cards.Card

Request fields:
  cid: optional int64

Usage:
  anki_as_code api cards get-card [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-card
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.cards.CardsService/RemoveCards

Request: anki.cards.RemoveCardsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  card_ids: repeated int64

Usage:
  anki_as_code api cards remove-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.cards.CardsService/SetDeck

Request: anki.cards.SetDeckRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  card_ids: repeated int64
  deck_id: optional int64

Usage:
  anki_as_code api cards set-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.cards.CardsService/SetFlag

Request: anki.cards.SetFlagRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  card_ids: repeated int64
  flag: optional uint32

Usage:
  anki_as_code api cards set-flag [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-flag
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.cards.CardsService/UpdateCards

Request: anki.cards.UpdateCardsRequest
Response: anki.collection.OpChanges

Request fields:
  cards: repeated anki.cards.Card
  skip_undo_entry: optional bool

Usage:
  anki_as_code api cards update-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.collection.CollectionService

Usage:
  anki_as_code api collection [command]

Available Commands:
  add-custom-undo-entry     /anki.collection.CollectionService/AddCustomUndoEntry
  check-database            /anki.collection.CollectionService/CheckDatabase
  get-custom-colours        /anki.collection.CollectionService/GetCustomColours
  get-undo-status           /anki.collection.CollectionService/GetUndoStatus
  latest-progress           /anki.collection.CollectionService/LatestProgress
  merge-undo-entries        /anki.collection.CollectionService/MergeUndoEntries
  redo                      /anki.collection.CollectionService/Redo
  set-load-balancer-enabled /anki.collection.CollectionService/SetLoadBalancerEnabled
  set-wants-abort           /anki.collection.CollectionService/SetWantsAbort
  undo                      /anki.collection.CollectionService/Undo

Flags:
  -h, --help   help for collection

Use "anki_as_code api collection [command] --help" for more information about a command.

anki_as_code api collection add-custom-undo-entry

/anki.collection.CollectionService/AddCustomUndoEntry

Request: anki.generic.String
Response: anki.generic.UInt32

Request fields:
  val: optional string

Usage:
  anki_as_code api collection add-custom-undo-entry [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-custom-undo-entry
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.CollectionService/CheckDatabase

Request: anki.generic.Empty
Response: anki.collection.CheckDatabaseResponse

Usage:
  anki_as_code api collection check-database [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for check-database
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.CollectionService/GetCustomColours

Request: anki.generic.Empty
Response: anki.collection.GetCustomColoursResponse

Usage:
  anki_as_code api collection get-custom-colours [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-custom-colours
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.CollectionService/GetUndoStatus

Request: anki.generic.Empty
Response: anki.collection.UndoStatus

Usage:
  anki_as_code api collection get-undo-status [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-undo-status
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.CollectionService/LatestProgress

Request: anki.generic.Empty
Response: anki.collection.Progress

Usage:
  anki_as_code api collection latest-progress [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for latest-progress
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.CollectionService/MergeUndoEntries

Request: anki.generic.UInt32
Response: anki.collection.OpChanges

Request fields:
  val: optional uint32

Usage:
  anki_as_code api collection merge-undo-entries [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for merge-undo-entries
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.CollectionService/Redo

Request: anki.generic.Empty
Response: anki.collection.OpChangesAfterUndo

Usage:
  anki_as_code api collection redo [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for redo
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.CollectionService/SetLoadBalancerEnabled

Request: anki.generic.Bool
Response: anki.collection.OpChanges

Request fields:
  val: optional bool

Usage:
  anki_as_code api collection set-load-balancer-enabled [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-load-balancer-enabled
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.CollectionService/SetWantsAbort

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api collection set-wants-abort [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-wants-abort
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.collection.CollectionService/Undo

Request: anki.generic.Empty
Response: anki.collection.OpChangesAfterUndo

Usage:
  anki_as_code api collection undo [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for undo
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.config.ConfigService

Usage:
  anki_as_code api config [command]

Available Commands:
  get-all-config          /anki.config.ConfigService/GetAllConfig
  get-config-bool         /anki.config.ConfigService/GetConfigBool
  get-config-json         /anki.config.ConfigService/GetConfigJson
  get-config-string       /anki.config.ConfigService/GetConfigString
  get-preferences         /anki.config.ConfigService/GetPreferences
  remove-config           /anki.config.ConfigService/RemoveConfig
  set-config-bool         /anki.config.ConfigService/SetConfigBool
  set-config-json         /anki.config.ConfigService/SetConfigJson
  set-config-json-no-undo /anki.config.ConfigService/SetConfigJsonNoUndo
  set-config-string       /anki.config.ConfigService/SetConfigString
  set-preferences         /anki.config.ConfigService/SetPreferences

Flags:
  -h, --help   help for config

Use "anki_as_code api config [command] --help" for more information about a command.

/anki.config.ConfigService/GetAllConfig

Request: anki.generic.Empty
Response: anki.generic.Json

Usage:
  anki_as_code api config get-all-config [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-all-config
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.ConfigService/GetConfigBool

Request: anki.config.GetConfigBoolRequest
Response: anki.generic.Bool

Request fields:
  key: optional anki.config.ConfigKey.Bool

Usage:
  anki_as_code api config get-config-bool [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-config-bool
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.ConfigService/GetConfigJson

Request: anki.generic.String
Response: anki.generic.Json

Request fields:
  val: optional string

Usage:
  anki_as_code api config get-config-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-config-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.ConfigService/GetConfigString

Request: anki.config.GetConfigStringRequest
Response: anki.generic.String

Request fields:
  key: optional anki.config.ConfigKey.String

Usage:
  anki_as_code api config get-config-string [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-config-string
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.ConfigService/GetPreferences

Request: anki.generic.Empty
Response: anki.config.Preferences

Usage:
  anki_as_code api config get-preferences [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-preferences
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.ConfigService/RemoveConfig

Request: anki.generic.String
Response: anki.collection.OpChanges

Request fields:
  val: optional string

Usage:
  anki_as_code api config remove-config [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-config
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.ConfigService/SetConfigBool

Request: anki.config.SetConfigBoolRequest
Response: anki.collection.OpChanges

Request fields:
  key: optional anki.config.ConfigKey.Bool
  value: optional bool
  undoable: optional bool

Usage:
  anki_as_code api config set-config-bool [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-config-bool
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.ConfigService/SetConfigJson

Request: anki.config.SetConfigJsonRequest
Response: anki.collection.OpChanges

Request fields:
  key: optional string
  value_json: optional bytes
  undoable: optional bool

Usage:
  anki_as_code api config set-config-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-config-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.ConfigService/SetConfigJsonNoUndo

Request: anki.config.SetConfigJsonRequest
Response: anki.generic.Empty

Request fields:
  key: optional string
  value_json: optional bytes
  undoable: optional bool

Usage:
  anki_as_code api config set-config-json-no-undo [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-config-json-no-undo
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.ConfigService/SetConfigString

Request: anki.config.SetConfigStringRequest
Response: anki.collection.OpChanges

Request fields:
  key: optional anki.config.ConfigKey.String
  value: optional string
  undoable: optional bool

Usage:
  anki_as_code api config set-config-string [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-config-string
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.config.ConfigService/SetPreferences

Request: anki.config.Preferences
Response: anki.collection.OpChanges

Request fields:
  scheduling: optional anki.config.Preferences.Scheduling
  reviewing: optional anki.config.Preferences.Reviewing
  editing: optional anki.config.Preferences.Editing
  backups: optional anki.config.Preferences.BackupLimits

Usage:
  anki_as_code api config set-preferences [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-preferences
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.deck_config.DeckConfigService

Usage:
  anki_as_code api deck-config [command]

Available Commands:
  add-or-update-deck-config-legacy /anki.deck_config.DeckConfigService/AddOrUpdateDeckConfigLegacy
  all-deck-config-legacy           /anki.deck_config.DeckConfigService/AllDeckConfigLegacy
  get-deck-config                  /anki.deck_config.DeckConfigService/GetDeckConfig
  get-deck-config-legacy           /anki.deck_config.DeckConfigService/GetDeckConfigLegacy
  get-deck-configs-for-update      /anki.deck_config.DeckConfigService/GetDeckConfigsForUpdate
  get-ignored-before-count         /anki.deck_config.DeckConfigService/GetIgnoredBeforeCount
  get-retention-workload           /anki.deck_config.DeckConfigService/GetRetentionWorkload
  new-deck-config-legacy           /anki.deck_config.DeckConfigService/NewDeckConfigLegacy
  remove-deck-config               /anki.deck_config.DeckConfigService/RemoveDeckConfig
  update-deck-configs              /anki.deck_config.DeckConfigService/UpdateDeckConfigs

Flags:
  -h, --help   help for deck-config

Use "anki_as_code api deck-config [command] --help" for more information about a command.

/anki.deck_config.DeckConfigService/AddOrUpdateDeckConfigLegacy

Request: anki.generic.Json
Response: anki.deck_config.DeckConfigId

Request fields:
  json: optional bytes

Usage:
  anki_as_code api deck-config add-or-update-deck-config-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-or-update-deck-config-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.DeckConfigService/AllDeckConfigLegacy

Request: anki.generic.Empty
Response: anki.generic.Json

Usage:
  anki_as_code api deck-config all-deck-config-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for all-deck-config-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.DeckConfigService/GetDeckConfig

Request: anki.deck_config.DeckConfigId
Response: anki.deck_config.DeckConfig

Request fields:
  dcid: optional int64

Usage:
  anki_as_code api deck-config get-deck-config [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-config
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.DeckConfigService/GetDeckConfigLegacy

Request: anki.deck_config.DeckConfigId
Response: anki.generic.Json

Request fields:
  dcid: optional int64

Usage:
  anki_as_code api deck-config get-deck-config-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-config-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.DeckConfigService/GetDeckConfigsForUpdate

Request: anki.decks.DeckId
Response: anki.deck_config.DeckConfigsForUpdate

Request fields:
  did: optional int64

Usage:
  anki_as_code api deck-config get-deck-configs-for-update [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-configs-for-update
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.DeckConfigService/GetIgnoredBeforeCount

Request: anki.deck_config.GetIgnoredBeforeCountRequest
Response: anki.deck_config.GetIgnoredBeforeCountResponse

Request fields:
  ignore_revlogs_before_date: optional string
  search: optional string

Usage:
  anki_as_code api deck-config get-ignored-before-count [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-ignored-before-count
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.DeckConfigService/GetRetentionWorkload

Request: anki.deck_config.GetRetentionWorkloadRequest
Response: anki.deck_config.GetRetentionWorkloadResponse

Request fields:
  w: repeated float
  search: optional string

Usage:
  anki_as_code api deck-config get-retention-workload [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-retention-workload
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.DeckConfigService/NewDeckConfigLegacy

Request: anki.generic.Empty
Response: anki.generic.Json

Usage:
  anki_as_code api deck-config new-deck-config-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for new-deck-config-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.DeckConfigService/RemoveDeckConfig

Request: anki.deck_config.DeckConfigId
Response: anki.generic.Empty

Request fields:
  dcid: optional int64

Usage:
  anki_as_code api deck-config remove-deck-config [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-deck-config
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.deck_config.DeckConfigService/UpdateDeckConfigs

Request: anki.deck_config.UpdateDeckConfigsRequest
Response: anki.collection.OpChanges

Request fields:
  target_deck_id: optional int64
  configs: repeated anki.deck_config.DeckConfig
  removed_config_ids: repeated int64
  mode: optional anki.deck_config.UpdateDeckConfigsMode
  card_state_customizer: optional string
  limits: optional anki.deck_config.DeckConfigsForUpdate.CurrentDeck.Limits
  new_cards_ignore_review_limit: optional bool
  fsrs: optional bool
  apply_all_parent_limits: optional bool
  fsrs_reschedule: optional bool
  fsrs_health_check: optional bool

Usage:
  anki_as_code api deck-config update-deck-configs [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-deck-configs
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.decks.DecksService

Usage:
  anki_as_code api decks [command]

Available Commands:
  add-deck                    /anki.decks.DecksService/AddDeck
  add-deck-legacy             /anki.decks.DecksService/AddDeckLegacy
  add-or-update-deck-legacy   /anki.decks.DecksService/AddOrUpdateDeckLegacy
  add-or-update-filtered-deck /anki.decks.DecksService/AddOrUpdateFilteredDeck
  deck-tree                   /anki.decks.DecksService/DeckTree
  deck-tree-legacy            /anki.decks.DecksService/DeckTreeLegacy
  filtered-deck-order-labels  /anki.decks.DecksService/FilteredDeckOrderLabels
  get-all-decks-legacy        /anki.decks.DecksService/GetAllDecksLegacy
  get-current-deck            /anki.decks.DecksService/GetCurrentDeck
  get-deck                    /anki.decks.DecksService/GetDeck
  get-deck-and-child-names    /anki.decks.DecksService/GetDeckAndChildNames
  get-deck-id-by-name         /anki.decks.DecksService/GetDeckIdByName
  get-deck-legacy             /anki.decks.DecksService/GetDeckLegacy
  get-deck-names              /anki.decks.DecksService/GetDeckNames
  get-or-create-filtered-deck /anki.decks.DecksService/GetOrCreateFilteredDeck
  new-deck                    /anki.decks.DecksService/NewDeck
  new-deck-legacy             /anki.decks.DecksService/NewDeckLegacy
  remove-decks                /anki.decks.DecksService/RemoveDecks
  rename-deck                 /anki.decks.DecksService/RenameDeck
  reparent-decks              /anki.decks.DecksService/ReparentDecks
  set-current-deck            /anki.decks.DecksService/SetCurrentDeck
  set-deck-collapsed          /anki.decks.DecksService/SetDeckCollapsed
  update-deck                 /anki.decks.DecksService/UpdateDeck
  update-deck-legacy          /anki.decks.DecksService/UpdateDeckLegacy

Flags:
  -h, --help   help for decks

Use "anki_as_code api decks [command] --help" for more information about a command.

/anki.decks.DecksService/AddDeck

Request: anki.decks.Deck
Response: anki.collection.OpChangesWithId

Request fields:
  id: optional int64
  name: optional string
  mtime_secs: optional int64
  usn: optional int32
  common: optional anki.decks.Deck.Common
  normal: optional anki.decks.Deck.Normal
  filtered: optional anki.decks.Deck.Filtered

Usage:
  anki_as_code api decks add-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/AddDeckLegacy

Request: anki.generic.Json
Response: anki.collection.OpChangesWithId

Request fields:
  json: optional bytes

Usage:
  anki_as_code api decks add-deck-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-deck-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/AddOrUpdateDeckLegacy

Request: anki.decks.AddOrUpdateDeckLegacyRequest
Response: anki.decks.DeckId

Request fields:
  deck: optional bytes
  preserve_usn_and_mtime: optional bool

Usage:
  anki_as_code api decks add-or-update-deck-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-or-update-deck-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/AddOrUpdateFilteredDeck

Request: anki.decks.FilteredDeckForUpdate
Response: anki.collection.OpChangesWithId

Request fields:
  id: optional int64
  name: optional string
  config: optional anki.decks.Deck.Filtered
  allow_empty: optional bool

Usage:
  anki_as_code api decks add-or-update-filtered-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-or-update-filtered-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/DeckTree

Request: anki.decks.DeckTreeRequest
Response: anki.decks.DeckTreeNode

Request fields:
  now: optional int64

Usage:
  anki_as_code api decks deck-tree [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for deck-tree
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/DeckTreeLegacy

Request: anki.generic.Empty
Response: anki.generic.Json

Usage:
  anki_as_code api decks deck-tree-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for deck-tree-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/FilteredDeckOrderLabels

Request: anki.generic.Empty
Response: anki.generic.StringList

Usage:
  anki_as_code api decks filtered-deck-order-labels [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for filtered-deck-order-labels
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/GetAllDecksLegacy

Request: anki.generic.Empty
Response: anki.generic.Json

Usage:
  anki_as_code api decks get-all-decks-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-all-decks-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/GetCurrentDeck

Request: anki.generic.Empty
Response: anki.decks.Deck

Usage:
  anki_as_code api decks get-current-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-current-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/GetDeck

Request: anki.decks.DeckId
Response: anki.decks.Deck

Request fields:
  did: optional int64

Usage:
  anki_as_code api decks get-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/GetDeckAndChildNames

Request: anki.decks.DeckId
Response: anki.decks.DeckNames

Request fields:
  did: optional int64

Usage:
  anki_as_code api decks get-deck-and-child-names [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-and-child-names
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/GetDeckIdByName

Request: anki.generic.String
Response: anki.decks.DeckId

Request fields:
  val: optional string

Usage:
  anki_as_code api decks get-deck-id-by-name [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-id-by-name
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/GetDeckLegacy

Request: anki.decks.DeckId
Response: anki.generic.Json

Request fields:
  did: optional int64

Usage:
  anki_as_code api decks get-deck-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/GetDeckNames

Request: anki.decks.GetDeckNamesRequest
Response: anki.decks.DeckNames

Request fields:
  skip_empty_default: optional bool
  include_filtered: optional bool

Usage:
  anki_as_code api decks get-deck-names [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-deck-names
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/GetOrCreateFilteredDeck

Request: anki.decks.DeckId
Response: anki.decks.FilteredDeckForUpdate

Request fields:
  did: optional int64

Usage:
  anki_as_code api decks get-or-create-filtered-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-or-create-filtered-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/NewDeck

Request: anki.generic.Empty
Response: anki.decks.Deck

Usage:
  anki_as_code api decks new-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for new-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/NewDeckLegacy

Request: anki.generic.Bool
Response: anki.generic.Json

Request fields:
  val: optional bool

Usage:
  anki_as_code api decks new-deck-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for new-deck-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/RemoveDecks

Request: anki.decks.DeckIds
Response: anki.collection.OpChangesWithCount

Request fields:
  dids: repeated int64

Usage:
  anki_as_code api decks remove-decks [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-decks
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/RenameDeck

Request: anki.decks.RenameDeckRequest
Response: anki.collection.OpChanges

Request fields:
  deck_id: optional int64
  new_name: optional string

Usage:
  anki_as_code api decks rename-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for rename-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/ReparentDecks

Request: anki.decks.ReparentDecksRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  deck_ids: repeated int64
  new_parent: optional int64

Usage:
  anki_as_code api decks reparent-decks [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for reparent-decks
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/SetCurrentDeck

Request: anki.decks.DeckId
Response: anki.collection.OpChanges

Request fields:
  did: optional int64

Usage:
  anki_as_code api decks set-current-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-current-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/SetDeckCollapsed

Request: anki.decks.SetDeckCollapsedRequest
Response: anki.collection.OpChanges

Request fields:
  deck_id: optional int64
  collapsed: optional bool
  scope: optional anki.decks.SetDeckCollapsedRequest.Scope

Usage:
  anki_as_code api decks set-deck-collapsed [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-deck-collapsed
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/UpdateDeck

Request: anki.decks.Deck
Response: anki.collection.OpChanges

Request fields:
  id: optional int64
  name: optional string
  mtime_secs: optional int64
  usn: optional int32
  common: optional anki.decks.Deck.Common
  normal: optional anki.decks.Deck.Normal
  filtered: optional anki.decks.Deck.Filtered

Usage:
  anki_as_code api decks update-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.decks.DecksService/UpdateDeckLegacy

Request: anki.generic.Json
Response: anki.collection.OpChanges

Request fields:
  json: optional bytes

Usage:
  anki_as_code api decks update-deck-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-deck-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.frontend.FrontendService

Usage:
  anki_as_code api frontend [command]

Available Commands:
  ask-user                           /anki.frontend.FrontendService/AskUser
  close-add-cards                    /anki.frontend.FrontendService/CloseAddCards
  close-edit-current                 /anki.frontend.FrontendService/CloseEditCurrent
  convert-pasted-image               /anki.frontend.FrontendService/ConvertPastedImage
  deck-options-ready                 /anki.frontend.FrontendService/deckOptionsReady
  deck-options-require-close         /anki.frontend.FrontendService/deckOptionsRequireClose
  get-meta-json                      /anki.frontend.FrontendService/GetMetaJson
  get-profile-config-json            /anki.frontend.FrontendService/GetProfileConfigJson
  get-scheduling-states-with-context /anki.frontend.FrontendService/GetSchedulingStatesWithContext
  import-dialog-require-close        /anki.frontend.FrontendService/ImportDialogRequireClose
  import-done                        /anki.frontend.FrontendService/ImportDone
  open-cards-dialog                  /anki.frontend.FrontendService/OpenCardsDialog
  open-fields-dialog                 /anki.frontend.FrontendService/OpenFieldsDialog
  open-file-picker                   /anki.frontend.FrontendService/OpenFilePicker
  open-link                          /anki.frontend.FrontendService/OpenLink
  open-media                         /anki.frontend.FrontendService/OpenMedia
  play-file                          /anki.frontend.FrontendService/PlayFile
  read-clipboard                     /anki.frontend.FrontendService/ReadClipboard
  record-audio                       /anki.frontend.FrontendService/RecordAudio
  save-custom-colours                /anki.frontend.FrontendService/SaveCustomColours
  search-in-browser                  /anki.frontend.FrontendService/SearchInBrowser
  set-meta-json                      /anki.frontend.FrontendService/SetMetaJson
  set-profile-config-json            /anki.frontend.FrontendService/SetProfileConfigJson
  set-scheduling-states              /anki.frontend.FrontendService/SetSchedulingStates
  show-in-media-folder               /anki.frontend.FrontendService/ShowInMediaFolder
  show-message-box                   /anki.frontend.FrontendService/ShowMessageBox
  write-clipboard                    /anki.frontend.FrontendService/WriteClipboard

Flags:
  -h, --help   help for frontend

Use "anki_as_code api frontend [command] --help" for more information about a command.

/anki.frontend.FrontendService/AskUser

Request: anki.frontend.AskUserRequest
Response: anki.generic.Bool

Request fields:
  text: optional string
  help: optional anki.frontend.Help
  title: optional string
  default_no: optional bool

Usage:
  anki_as_code api frontend ask-user [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for ask-user
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/CloseAddCards

Request: anki.generic.Bool
Response: anki.generic.Empty

Request fields:
  val: optional bool

Usage:
  anki_as_code api frontend close-add-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for close-add-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/CloseEditCurrent

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api frontend close-edit-current [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for close-edit-current
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/ConvertPastedImage

Request: anki.frontend.ConvertPastedImageRequest
Response: anki.frontend.ConvertPastedImageResponse

Request fields:
  data: optional bytes
  ext: optional string

Usage:
  anki_as_code api frontend convert-pasted-image [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for convert-pasted-image
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/deckOptionsReady

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api frontend deck-options-ready [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for deck-options-ready
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/deckOptionsRequireClose

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api frontend deck-options-require-close [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for deck-options-require-close
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/GetMetaJson

Request: anki.generic.String
Response: anki.generic.Json

Request fields:
  val: optional string

Usage:
  anki_as_code api frontend get-meta-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-meta-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/GetProfileConfigJson

Request: anki.generic.String
Response: anki.generic.Json

Request fields:
  val: optional string

Usage:
  anki_as_code api frontend get-profile-config-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-profile-config-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/GetSchedulingStatesWithContext

Request: anki.generic.Empty
Response: anki.frontend.SchedulingStatesWithContext

Usage:
  anki_as_code api frontend get-scheduling-states-with-context [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-scheduling-states-with-context
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/ImportDialogRequireClose

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api frontend import-dialog-require-close [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-dialog-require-close
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/ImportDone

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api frontend import-done [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-done
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/OpenCardsDialog

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api frontend open-cards-dialog [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-cards-dialog
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/OpenFieldsDialog

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api frontend open-fields-dialog [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-fields-dialog
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/OpenFilePicker

Request: anki.frontend.openFilePickerRequest
Response: anki.generic.String

Request fields:
  title: optional string
  key: optional string
  filter_description: optional string
  extensions: repeated string

Usage:
  anki_as_code api frontend open-file-picker [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-file-picker
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/OpenLink

Request: anki.generic.String
Response: anki.generic.Empty

Request fields:
  val: optional string

Usage:
  anki_as_code api frontend open-link [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-link
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/OpenMedia

Request: anki.generic.String
Response: anki.generic.Empty

Request fields:
  val: optional string

Usage:
  anki_as_code api frontend open-media [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for open-media
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/PlayFile

Request: anki.generic.String
Response: anki.generic.Empty

Request fields:
  val: optional string

Usage:
  anki_as_code api frontend play-file [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for play-file
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/ReadClipboard

Request: anki.frontend.ReadClipboardRequest
Response: anki.frontend.ReadClipboardResponse

Request fields:
  types: repeated string

Usage:
  anki_as_code api frontend read-clipboard [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for read-clipboard
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/RecordAudio

Request: anki.generic.Empty
Response: anki.generic.String

Usage:
  anki_as_code api frontend record-audio [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for record-audio
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/SaveCustomColours

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api frontend save-custom-colours [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for save-custom-colours
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/SearchInBrowser

Request: anki.search.SearchNode
Response: anki.generic.Empty

Request fields:
  group: optional anki.search.SearchNode.Group
  negated: optional anki.search.SearchNode
  parsable_text: optional string
  template: optional uint32
  nid: optional int64
  dupe: optional anki.search.SearchNode.Dupe
  field_name: optional string
  rated: optional anki.search.SearchNode.Rated
  added_in_days: optional uint32
  due_in_days: optional int32
  flag: optional anki.search.SearchNode.Flag
  card_state: optional anki.search.SearchNode.CardState
  nids: optional anki.search.SearchNode.IdList
  edited_in_days: optional uint32
  deck: optional string
  due_on_day: optional int32
  tag: optional string
  note: optional string
  introduced_in_days: optional uint32
  field: optional anki.search.SearchNode.Field
  literal_text: optional string

Usage:
  anki_as_code api frontend search-in-browser [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for search-in-browser
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/SetMetaJson

Request: anki.frontend.SetSettingJsonRequest
Response: anki.generic.Empty

Request fields:
  key: optional string
  value_json: optional bytes

Usage:
  anki_as_code api frontend set-meta-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-meta-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/SetProfileConfigJson

Request: anki.frontend.SetSettingJsonRequest
Response: anki.generic.Empty

Request fields:
  key: optional string
  value_json: optional bytes

Usage:
  anki_as_code api frontend set-profile-config-json [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-profile-config-json
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/SetSchedulingStates

Request: anki.frontend.SetSchedulingStatesRequest
Response: anki.generic.Empty

Request fields:
  key: optional string
  states: optional anki.scheduler.SchedulingStates

Usage:
  anki_as_code api frontend set-scheduling-states [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-scheduling-states
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/ShowInMediaFolder

Request: anki.generic.String
Response: anki.generic.Empty

Request fields:
  val: optional string

Usage:
  anki_as_code api frontend show-in-media-folder [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for show-in-media-folder
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/ShowMessageBox

Request: anki.frontend.ShowMessageBoxRequest
Response: anki.generic.Empty

Request fields:
  text: optional string
  type: optional anki.frontend.MessageBoxType
  help: optional anki.frontend.Help
  title: optional string
  text_format: optional string

Usage:
  anki_as_code api frontend show-message-box [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for show-message-box
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.frontend.FrontendService/WriteClipboard

Request: anki.frontend.WriteClipboardRequest
Response: anki.generic.Empty

Request fields:
  data: repeated anki.frontend.WriteClipboardRequest.DataEntry

Usage:
  anki_as_code api frontend write-clipboard [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for write-clipboard
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.github.GithubService

anki.i18n.I18nService

Usage:
  anki_as_code api i18n [command]

Available Commands:
  format-timespan  /anki.i18n.I18nService/FormatTimespan
  i18n-resources   /anki.i18n.I18nService/I18nResources
  translate-string /anki.i18n.I18nService/TranslateString

Flags:
  -h, --help   help for i18n

Use "anki_as_code api i18n [command] --help" for more information about a command.

/anki.i18n.I18nService/FormatTimespan

Request: anki.i18n.FormatTimespanRequest
Response: anki.generic.String

Request fields:
  seconds: optional float
  context: optional anki.i18n.FormatTimespanRequest.Context

Usage:
  anki_as_code api i18n format-timespan [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for format-timespan
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.i18n.I18nService/I18nResources

Request: anki.i18n.I18nResourcesRequest
Response: anki.generic.Json

Request fields:
  modules: repeated string

Usage:
  anki_as_code api i18n i18n-resources [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for i18n-resources
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.i18n.I18nService/TranslateString

Request: anki.i18n.TranslateStringRequest
Response: anki.generic.String

Request fields:
  module_index: optional uint32
  message_index: optional uint32
  args: repeated anki.i18n.TranslateStringRequest.ArgsEntry

Usage:
  anki_as_code api i18n translate-string [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for translate-string
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.image_occlusion.ImageOcclusionService

Usage:
  anki_as_code api image-occlusion [command]

Available Commands:
  add-image-occlusion-note     /anki.image_occlusion.ImageOcclusionService/AddImageOcclusionNote
  add-image-occlusion-notetype /anki.image_occlusion.ImageOcclusionService/AddImageOcclusionNotetype
  get-image-for-occlusion      /anki.image_occlusion.ImageOcclusionService/GetImageForOcclusion
  get-image-occlusion-fields   /anki.image_occlusion.ImageOcclusionService/GetImageOcclusionFields
  get-image-occlusion-note     /anki.image_occlusion.ImageOcclusionService/GetImageOcclusionNote
  update-image-occlusion-note  /anki.image_occlusion.ImageOcclusionService/UpdateImageOcclusionNote

Flags:
  -h, --help   help for image-occlusion

Use "anki_as_code api image-occlusion [command] --help" for more information about a command.

/anki.image_occlusion.ImageOcclusionService/AddImageOcclusionNote

Request: anki.image_occlusion.AddImageOcclusionNoteRequest
Response: anki.collection.OpChanges

Request fields:
  image_path: optional string
  occlusions: optional string
  header: optional string
  back_extra: optional string
  tags: repeated string
  notetype_id: optional int64

Usage:
  anki_as_code api image-occlusion add-image-occlusion-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-image-occlusion-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.image_occlusion.ImageOcclusionService/AddImageOcclusionNotetype

Request: anki.generic.Empty
Response: anki.collection.OpChanges

Usage:
  anki_as_code api image-occlusion add-image-occlusion-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-image-occlusion-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.image_occlusion.ImageOcclusionService/GetImageForOcclusion

Request: anki.image_occlusion.GetImageForOcclusionRequest
Response: anki.image_occlusion.GetImageForOcclusionResponse

Request fields:
  path: optional string

Usage:
  anki_as_code api image-occlusion get-image-for-occlusion [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-image-for-occlusion
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.image_occlusion.ImageOcclusionService/GetImageOcclusionFields

Request: anki.image_occlusion.GetImageOcclusionFieldsRequest
Response: anki.image_occlusion.GetImageOcclusionFieldsResponse

Request fields:
  notetype_id: optional int64

Usage:
  anki_as_code api image-occlusion get-image-occlusion-fields [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-image-occlusion-fields
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.image_occlusion.ImageOcclusionService/GetImageOcclusionNote

Request: anki.image_occlusion.GetImageOcclusionNoteRequest
Response: anki.image_occlusion.GetImageOcclusionNoteResponse

Request fields:
  note_id: optional int64

Usage:
  anki_as_code api image-occlusion get-image-occlusion-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-image-occlusion-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.image_occlusion.ImageOcclusionService/UpdateImageOcclusionNote

Request: anki.image_occlusion.UpdateImageOcclusionNoteRequest
Response: anki.collection.OpChanges

Request fields:
  note_id: optional int64
  occlusions: optional string
  header: optional string
  back_extra: optional string
  tags: repeated string

Usage:
  anki_as_code api image-occlusion update-image-occlusion-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-image-occlusion-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.import_export.ImportExportService

Usage:
  anki_as_code api import-export [command]

Available Commands:
  export-anki-package             /anki.import_export.ImportExportService/ExportAnkiPackage
  export-card-csv                 /anki.import_export.ImportExportService/ExportCardCsv
  export-note-csv                 /anki.import_export.ImportExportService/ExportNoteCsv
  get-csv-metadata                /anki.import_export.ImportExportService/GetCsvMetadata
  get-import-anki-package-presets /anki.import_export.ImportExportService/GetImportAnkiPackagePresets
  import-anki-package             /anki.import_export.ImportExportService/ImportAnkiPackage
  import-csv                      /anki.import_export.ImportExportService/ImportCsv
  import-json-file                /anki.import_export.ImportExportService/ImportJsonFile
  import-json-string              /anki.import_export.ImportExportService/ImportJsonString

Flags:
  -h, --help   help for import-export

Use "anki_as_code api import-export [command] --help" for more information about a command.

/anki.import_export.ImportExportService/ExportAnkiPackage

Request: anki.import_export.ExportAnkiPackageRequest
Response: anki.generic.UInt32

Request fields:
  out_path: optional string
  options: optional anki.import_export.ExportAnkiPackageOptions
  limit: optional anki.import_export.ExportLimit

Usage:
  anki_as_code api import-export export-anki-package [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for export-anki-package
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.ImportExportService/ExportCardCsv

Request: anki.import_export.ExportCardCsvRequest
Response: anki.generic.UInt32

Request fields:
  out_path: optional string
  with_html: optional bool
  limit: optional anki.import_export.ExportLimit

Usage:
  anki_as_code api import-export export-card-csv [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for export-card-csv
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.ImportExportService/ExportNoteCsv

Request: anki.import_export.ExportNoteCsvRequest
Response: anki.generic.UInt32

Request fields:
  out_path: optional string
  with_html: optional bool
  with_tags: optional bool
  with_deck: optional bool
  with_notetype: optional bool
  with_guid: optional bool
  limit: optional anki.import_export.ExportLimit

Usage:
  anki_as_code api import-export export-note-csv [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for export-note-csv
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.ImportExportService/GetCsvMetadata

Request: anki.import_export.CsvMetadataRequest
Response: anki.import_export.CsvMetadata

Request fields:
  path: optional string
  delimiter: optional anki.import_export.CsvMetadata.Delimiter
  notetype_id: optional int64
  deck_id: optional int64
  is_html: optional bool

Usage:
  anki_as_code api import-export get-csv-metadata [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-csv-metadata
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.ImportExportService/GetImportAnkiPackagePresets

Request: anki.generic.Empty
Response: anki.import_export.ImportAnkiPackageOptions

Usage:
  anki_as_code api import-export get-import-anki-package-presets [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-import-anki-package-presets
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.ImportExportService/ImportAnkiPackage

Request: anki.import_export.ImportAnkiPackageRequest
Response: anki.import_export.ImportResponse

Request fields:
  package_path: optional string
  options: optional anki.import_export.ImportAnkiPackageOptions

Usage:
  anki_as_code api import-export import-anki-package [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-anki-package
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.ImportExportService/ImportCsv

Request: anki.import_export.ImportCsvRequest
Response: anki.import_export.ImportResponse

Request fields:
  path: optional string
  metadata: optional anki.import_export.CsvMetadata

Usage:
  anki_as_code api import-export import-csv [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-csv
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.ImportExportService/ImportJsonFile

Request: anki.generic.String
Response: anki.import_export.ImportResponse

Request fields:
  val: optional string

Usage:
  anki_as_code api import-export import-json-file [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-json-file
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.import_export.ImportExportService/ImportJsonString

Request: anki.generic.String
Response: anki.import_export.ImportResponse

Request fields:
  val: optional string

Usage:
  anki_as_code api import-export import-json-string [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for import-json-string
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.links.LinksService

Usage:
  anki_as_code api links [command]

Available Commands:
  help-page-link /anki.links.LinksService/HelpPageLink

Flags:
  -h, --help   help for links

Use "anki_as_code api links [command] --help" for more information about a command.

anki_as_code api links help-page-link

/anki.links.LinksService/HelpPageLink

Request: anki.links.HelpPageLinkRequest
Response: anki.generic.String

Request fields:
  page: optional anki.links.HelpPageLinkRequest.HelpPage

Usage:
  anki_as_code api links help-page-link [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for help-page-link
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.media.MediaService

Usage:
  anki_as_code api media [command]

Available Commands:
  add-media-file             /anki.media.MediaService/AddMediaFile
  add-media-from-path        /anki.media.MediaService/AddMediaFromPath
  check-media                /anki.media.MediaService/CheckMedia
  empty-trash                /anki.media.MediaService/EmptyTrash
  extract-media-files        /anki.media.MediaService/ExtractMediaFiles
  extract-static-media-files /anki.media.MediaService/ExtractStaticMediaFiles
  get-absolute-media-path    /anki.media.MediaService/GetAbsoluteMediaPath
  restore-trash              /anki.media.MediaService/RestoreTrash
  trash-media-files          /anki.media.MediaService/TrashMediaFiles

Flags:
  -h, --help   help for media

Use "anki_as_code api media [command] --help" for more information about a command.

/anki.media.MediaService/AddMediaFile

Request: anki.media.AddMediaFileRequest
Response: anki.generic.String

Request fields:
  desired_name: optional string
  data: optional bytes

Usage:
  anki_as_code api media add-media-file [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-media-file
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.MediaService/AddMediaFromPath

Request: anki.media.AddMediaFromPathRequest
Response: anki.generic.String

Request fields:
  path: optional string

Usage:
  anki_as_code api media add-media-from-path [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-media-from-path
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.MediaService/CheckMedia

Request: anki.generic.Empty
Response: anki.media.CheckMediaResponse

Usage:
  anki_as_code api media check-media [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for check-media
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.MediaService/EmptyTrash

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api media empty-trash [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for empty-trash
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.MediaService/ExtractMediaFiles

Request: anki.generic.String
Response: anki.generic.StringList

Request fields:
  val: optional string

Usage:
  anki_as_code api media extract-media-files [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extract-media-files
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.MediaService/ExtractStaticMediaFiles

Request: anki.notetypes.NotetypeId
Response: anki.generic.StringList

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api media extract-static-media-files [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extract-static-media-files
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.MediaService/GetAbsoluteMediaPath

Request: anki.generic.String
Response: anki.generic.String

Request fields:
  val: optional string

Usage:
  anki_as_code api media get-absolute-media-path [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-absolute-media-path
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.MediaService/RestoreTrash

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api media restore-trash [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for restore-trash
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.media.MediaService/TrashMediaFiles

Request: anki.media.TrashMediaFilesRequest
Response: anki.generic.Empty

Request fields:
  fnames: repeated string

Usage:
  anki_as_code api media trash-media-files [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for trash-media-files
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.notes.NotesService

Usage:
  anki_as_code api notes [command]

Available Commands:
  add-note                     /anki.notes.NotesService/AddNote
  add-notes                    /anki.notes.NotesService/AddNotes
  after-note-updates           /anki.notes.NotesService/AfterNoteUpdates
  cards-of-note                /anki.notes.NotesService/CardsOfNote
  cloze-numbers-in-note        /anki.notes.NotesService/ClozeNumbersInNote
  default-deck-for-notetype    /anki.notes.NotesService/DefaultDeckForNotetype
  defaults-for-adding          /anki.notes.NotesService/DefaultsForAdding
  field-names-for-notes        /anki.notes.NotesService/FieldNamesForNotes
  get-note                     /anki.notes.NotesService/GetNote
  get-single-notetype-of-notes /anki.notes.NotesService/GetSingleNotetypeOfNotes
  new-note                     /anki.notes.NotesService/NewNote
  note-fields-check            /anki.notes.NotesService/NoteFieldsCheck
  remove-notes                 /anki.notes.NotesService/RemoveNotes
  update-notes                 /anki.notes.NotesService/UpdateNotes

Flags:
  -h, --help   help for notes

Use "anki_as_code api notes [command] --help" for more information about a command.

/anki.notes.NotesService/AddNote

Request: anki.notes.AddNoteRequest
Response: anki.notes.AddNoteResponse

Request fields:
  note: optional anki.notes.Note
  deck_id: optional int64

Usage:
  anki_as_code api notes add-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/AddNotes

Request: anki.notes.AddNotesRequest
Response: anki.notes.AddNotesResponse

Request fields:
  requests: repeated anki.notes.AddNoteRequest

Usage:
  anki_as_code api notes add-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/AfterNoteUpdates

Request: anki.notes.AfterNoteUpdatesRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  nids: repeated int64
  mark_notes_modified: optional bool
  generate_cards: optional bool

Usage:
  anki_as_code api notes after-note-updates [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for after-note-updates
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/CardsOfNote

Request: anki.notes.NoteId
Response: anki.cards.CardIds

Request fields:
  nid: optional int64

Usage:
  anki_as_code api notes cards-of-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for cards-of-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/ClozeNumbersInNote

Request: anki.notes.Note
Response: anki.notes.ClozeNumbersInNoteResponse

Request fields:
  id: optional int64
  guid: optional string
  notetype_id: optional int64
  mtime_secs: optional uint32
  usn: optional int32
  tags: repeated string
  fields: repeated string

Usage:
  anki_as_code api notes cloze-numbers-in-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for cloze-numbers-in-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/DefaultDeckForNotetype

Request: anki.notetypes.NotetypeId
Response: anki.decks.DeckId

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api notes default-deck-for-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for default-deck-for-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/DefaultsForAdding

Request: anki.notes.DefaultsForAddingRequest
Response: anki.notes.DeckAndNotetype

Request fields:
  home_deck_of_current_review_card: optional int64

Usage:
  anki_as_code api notes defaults-for-adding [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for defaults-for-adding
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/FieldNamesForNotes

Request: anki.notes.FieldNamesForNotesRequest
Response: anki.notes.FieldNamesForNotesResponse

Request fields:
  nids: repeated int64

Usage:
  anki_as_code api notes field-names-for-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for field-names-for-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/GetNote

Request: anki.notes.NoteId
Response: anki.notes.Note

Request fields:
  nid: optional int64

Usage:
  anki_as_code api notes get-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/GetSingleNotetypeOfNotes

Request: anki.notes.NoteIds
Response: anki.notetypes.NotetypeId

Request fields:
  note_ids: repeated int64

Usage:
  anki_as_code api notes get-single-notetype-of-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-single-notetype-of-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/NewNote

Request: anki.notetypes.NotetypeId
Response: anki.notes.Note

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api notes new-note [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for new-note
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/NoteFieldsCheck

Request: anki.notes.Note
Response: anki.notes.NoteFieldsCheckResponse

Request fields:
  id: optional int64
  guid: optional string
  notetype_id: optional int64
  mtime_secs: optional uint32
  usn: optional int32
  tags: repeated string
  fields: repeated string

Usage:
  anki_as_code api notes note-fields-check [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for note-fields-check
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/RemoveNotes

Request: anki.notes.RemoveNotesRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  note_ids: repeated int64
  card_ids: repeated int64

Usage:
  anki_as_code api notes remove-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notes.NotesService/UpdateNotes

Request: anki.notes.UpdateNotesRequest
Response: anki.collection.OpChanges

Request fields:
  notes: repeated anki.notes.Note
  skip_undo_entry: optional bool

Usage:
  anki_as_code api notes update-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.notetypes.NotetypesService

Usage:
  anki_as_code api notetypes [command]

Available Commands:
  add-notetype                  /anki.notetypes.NotetypesService/AddNotetype
  add-notetype-legacy           /anki.notetypes.NotetypesService/AddNotetypeLegacy
  add-or-update-notetype        /anki.notetypes.NotetypesService/AddOrUpdateNotetype
  change-notetype               /anki.notetypes.NotetypesService/ChangeNotetype
  get-aux-notetype-config-key   /anki.notetypes.NotetypesService/GetAuxNotetypeConfigKey
  get-aux-template-config-key   /anki.notetypes.NotetypesService/GetAuxTemplateConfigKey
  get-change-notetype-info      /anki.notetypes.NotetypesService/GetChangeNotetypeInfo
  get-cloze-field-ords          /anki.notetypes.NotetypesService/GetClozeFieldOrds
  get-field-names               /anki.notetypes.NotetypesService/GetFieldNames
  get-notetype                  /anki.notetypes.NotetypesService/GetNotetype
  get-notetype-id-by-name       /anki.notetypes.NotetypesService/GetNotetypeIdByName
  get-notetype-legacy           /anki.notetypes.NotetypesService/GetNotetypeLegacy
  get-notetype-names            /anki.notetypes.NotetypesService/GetNotetypeNames
  get-notetype-names-and-counts /anki.notetypes.NotetypesService/GetNotetypeNamesAndCounts
  get-stock-notetype-legacy     /anki.notetypes.NotetypesService/GetStockNotetypeLegacy
  remove-notetype               /anki.notetypes.NotetypesService/RemoveNotetype
  restore-notetype-to-stock     /anki.notetypes.NotetypesService/RestoreNotetypeToStock
  update-notetype               /anki.notetypes.NotetypesService/UpdateNotetype
  update-notetype-legacy        /anki.notetypes.NotetypesService/UpdateNotetypeLegacy

Flags:
  -h, --help   help for notetypes

Use "anki_as_code api notetypes [command] --help" for more information about a command.

/anki.notetypes.NotetypesService/AddNotetype

Request: anki.notetypes.Notetype
Response: anki.collection.OpChangesWithId

Request fields:
  id: optional int64
  name: optional string
  mtime_secs: optional int64
  usn: optional sint32
  config: optional anki.notetypes.Notetype.Config
  fields: repeated anki.notetypes.Notetype.Field
  templates: repeated anki.notetypes.Notetype.Template

Usage:
  anki_as_code api notetypes add-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/AddNotetypeLegacy

Request: anki.generic.Json
Response: anki.collection.OpChangesWithId

Request fields:
  json: optional bytes

Usage:
  anki_as_code api notetypes add-notetype-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-notetype-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/AddOrUpdateNotetype

Request: anki.notetypes.AddOrUpdateNotetypeRequest
Response: anki.notetypes.NotetypeId

Request fields:
  json: optional bytes
  preserve_usn_and_mtime: optional bool
  skip_checks: optional bool

Usage:
  anki_as_code api notetypes add-or-update-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-or-update-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/ChangeNotetype

Request: anki.notetypes.ChangeNotetypeRequest
Response: anki.collection.OpChanges

Request fields:
  note_ids: repeated int64
  new_fields: repeated int32
  new_templates: repeated int32
  old_notetype_id: optional int64
  new_notetype_id: optional int64
  current_schema: optional int64
  old_notetype_name: optional string
  is_cloze: optional bool

Usage:
  anki_as_code api notetypes change-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for change-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetAuxNotetypeConfigKey

Request: anki.notetypes.GetAuxConfigKeyRequest
Response: anki.generic.String

Request fields:
  id: optional int64
  key: optional string

Usage:
  anki_as_code api notetypes get-aux-notetype-config-key [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-aux-notetype-config-key
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetAuxTemplateConfigKey

Request: anki.notetypes.GetAuxTemplateConfigKeyRequest
Response: anki.generic.String

Request fields:
  notetype_id: optional int64
  card_ordinal: optional uint32
  key: optional string

Usage:
  anki_as_code api notetypes get-aux-template-config-key [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-aux-template-config-key
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetChangeNotetypeInfo

Request: anki.notetypes.GetChangeNotetypeInfoRequest
Response: anki.notetypes.ChangeNotetypeInfo

Request fields:
  old_notetype_id: optional int64
  new_notetype_id: optional int64

Usage:
  anki_as_code api notetypes get-change-notetype-info [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-change-notetype-info
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetClozeFieldOrds

Request: anki.notetypes.NotetypeId
Response: anki.notetypes.GetClozeFieldOrdsResponse

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api notetypes get-cloze-field-ords [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-cloze-field-ords
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetFieldNames

Request: anki.notetypes.NotetypeId
Response: anki.generic.StringList

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api notetypes get-field-names [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-field-names
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetNotetype

Request: anki.notetypes.NotetypeId
Response: anki.notetypes.Notetype

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api notetypes get-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetNotetypeIdByName

Request: anki.generic.String
Response: anki.notetypes.NotetypeId

Request fields:
  val: optional string

Usage:
  anki_as_code api notetypes get-notetype-id-by-name [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-notetype-id-by-name
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetNotetypeLegacy

Request: anki.notetypes.NotetypeId
Response: anki.generic.Json

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api notetypes get-notetype-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-notetype-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetNotetypeNames

Request: anki.generic.Empty
Response: anki.notetypes.NotetypeNames

Usage:
  anki_as_code api notetypes get-notetype-names [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-notetype-names
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetNotetypeNamesAndCounts

Request: anki.generic.Empty
Response: anki.notetypes.NotetypeUseCounts

Usage:
  anki_as_code api notetypes get-notetype-names-and-counts [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-notetype-names-and-counts
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/GetStockNotetypeLegacy

Request: anki.notetypes.StockNotetype
Response: anki.generic.Json

Request fields:
  kind: optional anki.notetypes.StockNotetype.Kind

Usage:
  anki_as_code api notetypes get-stock-notetype-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-stock-notetype-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/RemoveNotetype

Request: anki.notetypes.NotetypeId
Response: anki.collection.OpChanges

Request fields:
  ntid: optional int64

Usage:
  anki_as_code api notetypes remove-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/RestoreNotetypeToStock

Request: anki.notetypes.RestoreNotetypeToStockRequest
Response: anki.collection.OpChanges

Request fields:
  notetype_id: optional anki.notetypes.NotetypeId
  force_kind: optional anki.notetypes.StockNotetype.Kind

Usage:
  anki_as_code api notetypes restore-notetype-to-stock [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for restore-notetype-to-stock
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/UpdateNotetype

Request: anki.notetypes.Notetype
Response: anki.collection.OpChanges

Request fields:
  id: optional int64
  name: optional string
  mtime_secs: optional int64
  usn: optional sint32
  config: optional anki.notetypes.Notetype.Config
  fields: repeated anki.notetypes.Notetype.Field
  templates: repeated anki.notetypes.Notetype.Template

Usage:
  anki_as_code api notetypes update-notetype [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-notetype
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.notetypes.NotetypesService/UpdateNotetypeLegacy

Request: anki.notetypes.UpdateNotetypeLegacyRequest
Response: anki.collection.OpChanges

Request fields:
  json: optional bytes
  skip_checks: optional bool

Usage:
  anki_as_code api notetypes update-notetype-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-notetype-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.scheduler.SchedulerService

Usage:
  anki_as_code api scheduler [command]

Available Commands:
  answer-card                        /anki.scheduler.SchedulerService/AnswerCard
  bury-or-suspend-cards              /anki.scheduler.SchedulerService/BuryOrSuspendCards
  compute-fsrs-params                /anki.scheduler.SchedulerService/ComputeFsrsParams
  compute-memory-state               /anki.scheduler.SchedulerService/ComputeMemoryState
  compute-optimal-retention          /anki.scheduler.SchedulerService/ComputeOptimalRetention
  congrats-info                      /anki.scheduler.SchedulerService/CongratsInfo
  counts-for-deck-today              /anki.scheduler.SchedulerService/CountsForDeckToday
  custom-study                       /anki.scheduler.SchedulerService/CustomStudy
  custom-study-defaults              /anki.scheduler.SchedulerService/CustomStudyDefaults
  describe-next-states               /anki.scheduler.SchedulerService/DescribeNextStates
  empty-filtered-deck                /anki.scheduler.SchedulerService/EmptyFilteredDeck
  evaluate-params                    /anki.scheduler.SchedulerService/EvaluateParams
  evaluate-params-legacy             /anki.scheduler.SchedulerService/EvaluateParamsLegacy
  extend-limits                      /anki.scheduler.SchedulerService/ExtendLimits
  fuzz-delta                         /anki.scheduler.SchedulerService/FuzzDelta
  get-optimal-retention-parameters   /anki.scheduler.SchedulerService/GetOptimalRetentionParameters
  get-queued-cards                   /anki.scheduler.SchedulerService/GetQueuedCards
  get-scheduling-states              /anki.scheduler.SchedulerService/GetSchedulingStates
  grade-now                          /anki.scheduler.SchedulerService/GradeNow
  rebuild-filtered-deck              /anki.scheduler.SchedulerService/RebuildFilteredDeck
  reposition-defaults                /anki.scheduler.SchedulerService/RepositionDefaults
  restore-buried-and-suspended-cards /anki.scheduler.SchedulerService/RestoreBuriedAndSuspendedCards
  sched-timing-today                 /anki.scheduler.SchedulerService/SchedTimingToday
  schedule-cards-as-new              /anki.scheduler.SchedulerService/ScheduleCardsAsNew
  schedule-cards-as-new-defaults     /anki.scheduler.SchedulerService/ScheduleCardsAsNewDefaults
  set-due-date                       /anki.scheduler.SchedulerService/SetDueDate
  simulate-fsrs-review               /anki.scheduler.SchedulerService/SimulateFsrsReview
  simulate-fsrs-workload             /anki.scheduler.SchedulerService/SimulateFsrsWorkload
  sort-cards                         /anki.scheduler.SchedulerService/SortCards
  sort-deck                          /anki.scheduler.SchedulerService/SortDeck
  state-is-leech                     /anki.scheduler.SchedulerService/StateIsLeech
  studied-today                      /anki.scheduler.SchedulerService/StudiedToday
  studied-today-message              /anki.scheduler.SchedulerService/StudiedTodayMessage
  unbury-deck                        /anki.scheduler.SchedulerService/UnburyDeck
  update-stats                       /anki.scheduler.SchedulerService/UpdateStats
  upgrade-scheduler                  /anki.scheduler.SchedulerService/UpgradeScheduler

Flags:
  -h, --help   help for scheduler

Use "anki_as_code api scheduler [command] --help" for more information about a command.

/anki.scheduler.SchedulerService/AnswerCard

Request: anki.scheduler.CardAnswer
Response: anki.collection.OpChanges

Request fields:
  card_id: optional int64
  current_state: optional anki.scheduler.SchedulingState
  new_state: optional anki.scheduler.SchedulingState
  rating: optional anki.scheduler.CardAnswer.Rating
  answered_at_millis: optional int64
  milliseconds_taken: optional uint32

Usage:
  anki_as_code api scheduler answer-card [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for answer-card
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/BuryOrSuspendCards

Request: anki.scheduler.BuryOrSuspendCardsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  card_ids: repeated int64
  note_ids: repeated int64
  mode: optional anki.scheduler.BuryOrSuspendCardsRequest.Mode

Usage:
  anki_as_code api scheduler bury-or-suspend-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for bury-or-suspend-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/ComputeFsrsParams

Request: anki.scheduler.ComputeFsrsParamsRequest
Response: anki.scheduler.ComputeFsrsParamsResponse

Request fields:
  search: optional string
  current_params: repeated float
  ignore_revlogs_before_ms: optional int64
  num_of_relearning_steps: optional uint32
  health_check: optional bool

Usage:
  anki_as_code api scheduler compute-fsrs-params [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for compute-fsrs-params
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/ComputeMemoryState

Request: anki.cards.CardId
Response: anki.scheduler.ComputeMemoryStateResponse

Request fields:
  cid: optional int64

Usage:
  anki_as_code api scheduler compute-memory-state [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for compute-memory-state
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/ComputeOptimalRetention

Request: anki.scheduler.SimulateFsrsReviewRequest
Response: anki.scheduler.ComputeOptimalRetentionResponse

Request fields:
  params: repeated float
  desired_retention: optional float
  deck_size: optional uint32
  days_to_simulate: optional uint32
  new_limit: optional uint32
  review_limit: optional uint32
  max_interval: optional uint32
  search: optional string
  new_cards_ignore_review_limit: optional bool
  easy_days_percentages: repeated float
  review_order: optional anki.deck_config.DeckConfig.Config.ReviewCardOrder
  suspend_after_lapse_count: optional uint32
  historical_retention: optional float
  learning_step_count: optional uint32
  relearning_step_count: optional uint32

Usage:
  anki_as_code api scheduler compute-optimal-retention [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for compute-optimal-retention
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/CongratsInfo

Request: anki.generic.Empty
Response: anki.scheduler.CongratsInfoResponse

Usage:
  anki_as_code api scheduler congrats-info [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for congrats-info
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/CountsForDeckToday

Request: anki.decks.DeckId
Response: anki.scheduler.CountsForDeckTodayResponse

Request fields:
  did: optional int64

Usage:
  anki_as_code api scheduler counts-for-deck-today [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for counts-for-deck-today
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/CustomStudy

Request: anki.scheduler.CustomStudyRequest
Response: anki.collection.OpChanges

Request fields:
  deck_id: optional int64
  new_limit_delta: optional int32
  review_limit_delta: optional int32
  forgot_days: optional uint32
  review_ahead_days: optional uint32
  preview_days: optional uint32
  cram: optional anki.scheduler.CustomStudyRequest.Cram

Usage:
  anki_as_code api scheduler custom-study [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for custom-study
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/CustomStudyDefaults

Request: anki.scheduler.CustomStudyDefaultsRequest
Response: anki.scheduler.CustomStudyDefaultsResponse

Request fields:
  deck_id: optional int64

Usage:
  anki_as_code api scheduler custom-study-defaults [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for custom-study-defaults
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/DescribeNextStates

Request: anki.scheduler.SchedulingStates
Response: anki.generic.StringList

Request fields:
  current: optional anki.scheduler.SchedulingState
  again: optional anki.scheduler.SchedulingState
  hard: optional anki.scheduler.SchedulingState
  good: optional anki.scheduler.SchedulingState
  easy: optional anki.scheduler.SchedulingState

Usage:
  anki_as_code api scheduler describe-next-states [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for describe-next-states
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/EmptyFilteredDeck

Request: anki.decks.DeckId
Response: anki.collection.OpChanges

Request fields:
  did: optional int64

Usage:
  anki_as_code api scheduler empty-filtered-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for empty-filtered-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/EvaluateParams

Request: anki.scheduler.EvaluateParamsRequest
Response: anki.scheduler.EvaluateParamsResponse

Request fields:
  search: optional string
  ignore_revlogs_before_ms: optional int64
  num_of_relearning_steps: optional uint32

Usage:
  anki_as_code api scheduler evaluate-params [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for evaluate-params
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/EvaluateParamsLegacy

Request: anki.scheduler.EvaluateParamsLegacyRequest
Response: anki.scheduler.EvaluateParamsResponse

Request fields:
  params: repeated float
  search: optional string
  ignore_revlogs_before_ms: optional int64

Usage:
  anki_as_code api scheduler evaluate-params-legacy [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for evaluate-params-legacy
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/ExtendLimits

Request: anki.scheduler.ExtendLimitsRequest
Response: anki.generic.Empty

Request fields:
  deck_id: optional int64
  new_delta: optional int32
  review_delta: optional int32

Usage:
  anki_as_code api scheduler extend-limits [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for extend-limits
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/FuzzDelta

Request: anki.scheduler.FuzzDeltaRequest
Response: anki.scheduler.FuzzDeltaResponse

Request fields:
  card_id: optional int64
  interval: optional uint32

Usage:
  anki_as_code api scheduler fuzz-delta [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for fuzz-delta
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/GetOptimalRetentionParameters

Request: anki.scheduler.GetOptimalRetentionParametersRequest
Response: anki.scheduler.GetOptimalRetentionParametersResponse

Request fields:
  search: optional string

Usage:
  anki_as_code api scheduler get-optimal-retention-parameters [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-optimal-retention-parameters
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/GetQueuedCards

Request: anki.scheduler.GetQueuedCardsRequest
Response: anki.scheduler.QueuedCards

Request fields:
  fetch_limit: optional uint32
  intraday_learning_only: optional bool

Usage:
  anki_as_code api scheduler get-queued-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-queued-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/GetSchedulingStates

Request: anki.cards.CardId
Response: anki.scheduler.SchedulingStates

Request fields:
  cid: optional int64

Usage:
  anki_as_code api scheduler get-scheduling-states [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-scheduling-states
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/GradeNow

Request: anki.scheduler.GradeNowRequest
Response: anki.collection.OpChanges

Request fields:
  card_ids: repeated int64
  rating: optional anki.scheduler.CardAnswer.Rating

Usage:
  anki_as_code api scheduler grade-now [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for grade-now
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/RebuildFilteredDeck

Request: anki.decks.DeckId
Response: anki.collection.OpChangesWithCount

Request fields:
  did: optional int64

Usage:
  anki_as_code api scheduler rebuild-filtered-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for rebuild-filtered-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/RepositionDefaults

Request: anki.generic.Empty
Response: anki.scheduler.RepositionDefaultsResponse

Usage:
  anki_as_code api scheduler reposition-defaults [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for reposition-defaults
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/RestoreBuriedAndSuspendedCards

Request: anki.cards.CardIds
Response: anki.collection.OpChanges

Request fields:
  cids: repeated int64

Usage:
  anki_as_code api scheduler restore-buried-and-suspended-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for restore-buried-and-suspended-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/SchedTimingToday

Request: anki.generic.Empty
Response: anki.scheduler.SchedTimingTodayResponse

Usage:
  anki_as_code api scheduler sched-timing-today [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sched-timing-today
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/ScheduleCardsAsNew

Request: anki.scheduler.ScheduleCardsAsNewRequest
Response: anki.collection.OpChanges

Request fields:
  card_ids: repeated int64
  log: optional bool
  restore_position: optional bool
  reset_counts: optional bool
  context: optional anki.scheduler.ScheduleCardsAsNewRequest.Context

Usage:
  anki_as_code api scheduler schedule-cards-as-new [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for schedule-cards-as-new
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/ScheduleCardsAsNewDefaults

Request: anki.scheduler.ScheduleCardsAsNewDefaultsRequest
Response: anki.scheduler.ScheduleCardsAsNewDefaultsResponse

Request fields:
  context: optional anki.scheduler.ScheduleCardsAsNewRequest.Context

Usage:
  anki_as_code api scheduler schedule-cards-as-new-defaults [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for schedule-cards-as-new-defaults
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/SetDueDate

Request: anki.scheduler.SetDueDateRequest
Response: anki.collection.OpChanges

Request fields:
  card_ids: repeated int64
  days: optional string
  config_key: optional anki.config.OptionalStringConfigKey

Usage:
  anki_as_code api scheduler set-due-date [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-due-date
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/SimulateFsrsReview

Request: anki.scheduler.SimulateFsrsReviewRequest
Response: anki.scheduler.SimulateFsrsReviewResponse

Request fields:
  params: repeated float
  desired_retention: optional float
  deck_size: optional uint32
  days_to_simulate: optional uint32
  new_limit: optional uint32
  review_limit: optional uint32
  max_interval: optional uint32
  search: optional string
  new_cards_ignore_review_limit: optional bool
  easy_days_percentages: repeated float
  review_order: optional anki.deck_config.DeckConfig.Config.ReviewCardOrder
  suspend_after_lapse_count: optional uint32
  historical_retention: optional float
  learning_step_count: optional uint32
  relearning_step_count: optional uint32

Usage:
  anki_as_code api scheduler simulate-fsrs-review [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for simulate-fsrs-review
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/SimulateFsrsWorkload

Request: anki.scheduler.SimulateFsrsReviewRequest
Response: anki.scheduler.SimulateFsrsWorkloadResponse

Request fields:
  params: repeated float
  desired_retention: optional float
  deck_size: optional uint32
  days_to_simulate: optional uint32
  new_limit: optional uint32
  review_limit: optional uint32
  max_interval: optional uint32
  search: optional string
  new_cards_ignore_review_limit: optional bool
  easy_days_percentages: repeated float
  review_order: optional anki.deck_config.DeckConfig.Config.ReviewCardOrder
  suspend_after_lapse_count: optional uint32
  historical_retention: optional float
  learning_step_count: optional uint32
  relearning_step_count: optional uint32

Usage:
  anki_as_code api scheduler simulate-fsrs-workload [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for simulate-fsrs-workload
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/SortCards

Request: anki.scheduler.SortCardsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  card_ids: repeated int64
  starting_from: optional uint32
  step_size: optional uint32
  randomize: optional bool
  shift_existing: optional bool

Usage:
  anki_as_code api scheduler sort-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sort-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/SortDeck

Request: anki.scheduler.SortDeckRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  deck_id: optional int64
  randomize: optional bool

Usage:
  anki_as_code api scheduler sort-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for sort-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/StateIsLeech

Request: anki.scheduler.SchedulingState
Response: anki.generic.Bool

Request fields:
  normal: optional anki.scheduler.SchedulingState.Normal
  filtered: optional anki.scheduler.SchedulingState.Filtered
  custom_data: optional string

Usage:
  anki_as_code api scheduler state-is-leech [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for state-is-leech
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/StudiedToday

Request: anki.generic.Empty
Response: anki.generic.String

Usage:
  anki_as_code api scheduler studied-today [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for studied-today
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/StudiedTodayMessage

Request: anki.scheduler.StudiedTodayMessageRequest
Response: anki.generic.String

Request fields:
  cards: optional uint32
  seconds: optional double

Usage:
  anki_as_code api scheduler studied-today-message [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for studied-today-message
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/UnburyDeck

Request: anki.scheduler.UnburyDeckRequest
Response: anki.collection.OpChanges

Request fields:
  deck_id: optional int64
  mode: optional anki.scheduler.UnburyDeckRequest.Mode

Usage:
  anki_as_code api scheduler unbury-deck [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for unbury-deck
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/UpdateStats

Request: anki.scheduler.UpdateStatsRequest
Response: anki.generic.Empty

Request fields:
  deck_id: optional int64
  new_delta: optional int32
  review_delta: optional int32
  millisecond_delta: optional int32

Usage:
  anki_as_code api scheduler update-stats [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for update-stats
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.scheduler.SchedulerService/UpgradeScheduler

Request: anki.generic.Empty
Response: anki.generic.Empty

Usage:
  anki_as_code api scheduler upgrade-scheduler [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for upgrade-scheduler
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.search.SearchService

Usage:
  anki_as_code api search [command]

Available Commands:
  all-browser-columns        /anki.search.SearchService/AllBrowserColumns
  browser-row-for-id         /anki.search.SearchService/BrowserRowForId
  build-search-string        /anki.search.SearchService/BuildSearchString
  find-and-replace           /anki.search.SearchService/FindAndReplace
  join-search-nodes          /anki.search.SearchService/JoinSearchNodes
  replace-search-node        /anki.search.SearchService/ReplaceSearchNode
  search-cards               /anki.search.SearchService/SearchCards
  search-notes               /anki.search.SearchService/SearchNotes
  set-active-browser-columns /anki.search.SearchService/SetActiveBrowserColumns

Flags:
  -h, --help   help for search

Use "anki_as_code api search [command] --help" for more information about a command.

/anki.search.SearchService/AllBrowserColumns

Request: anki.generic.Empty
Response: anki.search.BrowserColumns

Usage:
  anki_as_code api search all-browser-columns [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for all-browser-columns
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.SearchService/BrowserRowForId

Request: anki.generic.Int64
Response: anki.search.BrowserRow

Request fields:
  val: optional int64

Usage:
  anki_as_code api search browser-row-for-id [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for browser-row-for-id
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.SearchService/BuildSearchString

Request: anki.search.SearchNode
Response: anki.generic.String

Request fields:
  group: optional anki.search.SearchNode.Group
  negated: optional anki.search.SearchNode
  parsable_text: optional string
  template: optional uint32
  nid: optional int64
  dupe: optional anki.search.SearchNode.Dupe
  field_name: optional string
  rated: optional anki.search.SearchNode.Rated
  added_in_days: optional uint32
  due_in_days: optional int32
  flag: optional anki.search.SearchNode.Flag
  card_state: optional anki.search.SearchNode.CardState
  nids: optional anki.search.SearchNode.IdList
  edited_in_days: optional uint32
  deck: optional string
  due_on_day: optional int32
  tag: optional string
  note: optional string
  introduced_in_days: optional uint32
  field: optional anki.search.SearchNode.Field
  literal_text: optional string

Usage:
  anki_as_code api search build-search-string [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for build-search-string
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.SearchService/FindAndReplace

Request: anki.search.FindAndReplaceRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  nids: repeated int64
  search: optional string
  replacement: optional string
  regex: optional bool
  match_case: optional bool
  field_name: optional string

Usage:
  anki_as_code api search find-and-replace [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for find-and-replace
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.SearchService/JoinSearchNodes

Request: anki.search.JoinSearchNodesRequest
Response: anki.generic.String

Request fields:
  joiner: optional anki.search.SearchNode.Group.Joiner
  existing_node: optional anki.search.SearchNode
  additional_node: optional anki.search.SearchNode

Usage:
  anki_as_code api search join-search-nodes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for join-search-nodes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.SearchService/ReplaceSearchNode

Request: anki.search.ReplaceSearchNodeRequest
Response: anki.generic.String

Request fields:
  existing_node: optional anki.search.SearchNode
  replacement_node: optional anki.search.SearchNode

Usage:
  anki_as_code api search replace-search-node [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for replace-search-node
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.SearchService/SearchCards

Request: anki.search.SearchRequest
Response: anki.search.SearchResponse

Request fields:
  search: optional string
  order: optional anki.search.SortOrder

Usage:
  anki_as_code api search search-cards [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for search-cards
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.SearchService/SearchNotes

Request: anki.search.SearchRequest
Response: anki.search.SearchResponse

Request fields:
  search: optional string
  order: optional anki.search.SortOrder

Usage:
  anki_as_code api search search-notes [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for search-notes
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.search.SearchService/SetActiveBrowserColumns

Request: anki.generic.StringList
Response: anki.generic.Empty

Request fields:
  vals: repeated string

Usage:
  anki_as_code api search set-active-browser-columns [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-active-browser-columns
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.stats.StatsService

Usage:
  anki_as_code api stats [command]

Available Commands:
  card-stats            /anki.stats.StatsService/CardStats
  get-graph-preferences /anki.stats.StatsService/GetGraphPreferences
  get-review-logs       /anki.stats.StatsService/GetReviewLogs
  graphs                /anki.stats.StatsService/Graphs
  set-graph-preferences /anki.stats.StatsService/SetGraphPreferences

Flags:
  -h, --help   help for stats

Use "anki_as_code api stats [command] --help" for more information about a command.

/anki.stats.StatsService/CardStats

Request: anki.cards.CardId
Response: anki.stats.CardStatsResponse

Request fields:
  cid: optional int64

Usage:
  anki_as_code api stats card-stats [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for card-stats
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.stats.StatsService/GetGraphPreferences

Request: anki.generic.Empty
Response: anki.stats.GraphPreferences

Usage:
  anki_as_code api stats get-graph-preferences [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-graph-preferences
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.stats.StatsService/GetReviewLogs

Request: anki.cards.CardId
Response: anki.stats.ReviewLogs

Request fields:
  cid: optional int64

Usage:
  anki_as_code api stats get-review-logs [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for get-review-logs
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.stats.StatsService/Graphs

Request: anki.stats.GraphsRequest
Response: anki.stats.GraphsResponse

Request fields:
  search: optional string
  days: optional uint32

Usage:
  anki_as_code api stats graphs [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for graphs
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.stats.StatsService/SetGraphPreferences

Request: anki.stats.GraphPreferences
Response: anki.generic.Empty

Request fields:
  calendar_first_day_of_week: optional anki.stats.GraphPreferences.Weekday
  card_counts_separate_inactive: optional bool
  browser_links_supported: optional bool
  future_due_show_backlog: optional bool

Usage:
  anki_as_code api stats set-graph-preferences [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-graph-preferences
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

anki.sync.SyncService

anki.tags.TagsService

Usage:
  anki_as_code api tags [command]

Available Commands:
  add-note-tags        /anki.tags.TagsService/AddNoteTags
  all-tags             /anki.tags.TagsService/AllTags
  clear-unused-tags    /anki.tags.TagsService/ClearUnusedTags
  complete-tag         /anki.tags.TagsService/CompleteTag
  find-and-replace-tag /anki.tags.TagsService/FindAndReplaceTag
  remove-note-tags     /anki.tags.TagsService/RemoveNoteTags
  remove-tags          /anki.tags.TagsService/RemoveTags
  rename-tags          /anki.tags.TagsService/RenameTags
  reparent-tags        /anki.tags.TagsService/ReparentTags
  set-tag-collapsed    /anki.tags.TagsService/SetTagCollapsed
  tag-tree             /anki.tags.TagsService/TagTree

Flags:
  -h, --help   help for tags

Use "anki_as_code api tags [command] --help" for more information about a command.

/anki.tags.TagsService/AddNoteTags

Request: anki.tags.NoteIdsAndTagsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  note_ids: repeated int64
  tags: optional string

Usage:
  anki_as_code api tags add-note-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for add-note-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.TagsService/AllTags

Request: anki.generic.Empty
Response: anki.generic.StringList

Usage:
  anki_as_code api tags all-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for all-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.TagsService/ClearUnusedTags

Request: anki.generic.Empty
Response: anki.collection.OpChangesWithCount

Usage:
  anki_as_code api tags clear-unused-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for clear-unused-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.TagsService/CompleteTag

Request: anki.tags.CompleteTagRequest
Response: anki.tags.CompleteTagResponse

Request fields:
  input: optional string
  match_limit: optional uint32

Usage:
  anki_as_code api tags complete-tag [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for complete-tag
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.TagsService/FindAndReplaceTag

Request: anki.tags.FindAndReplaceTagRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  note_ids: repeated int64
  search: optional string
  replacement: optional string
  regex: optional bool
  match_case: optional bool

Usage:
  anki_as_code api tags find-and-replace-tag [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for find-and-replace-tag
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.TagsService/RemoveNoteTags

Request: anki.tags.NoteIdsAndTagsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  note_ids: repeated int64
  tags: optional string

Usage:
  anki_as_code api tags remove-note-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-note-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.TagsService/RemoveTags

Request: anki.generic.String
Response: anki.collection.OpChangesWithCount

Request fields:
  val: optional string

Usage:
  anki_as_code api tags remove-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for remove-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.TagsService/RenameTags

Request: anki.tags.RenameTagsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  current_prefix: optional string
  new_prefix: optional string

Usage:
  anki_as_code api tags rename-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for rename-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.TagsService/ReparentTags

Request: anki.tags.ReparentTagsRequest
Response: anki.collection.OpChangesWithCount

Request fields:
  tags: repeated string
  new_parent: optional string

Usage:
  anki_as_code api tags reparent-tags [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for reparent-tags
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.TagsService/SetTagCollapsed

Request: anki.tags.SetTagCollapsedRequest
Response: anki.collection.OpChanges

Request fields:
  name: optional string
  collapsed: optional bool

Usage:
  anki_as_code api tags set-tag-collapsed [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for set-tag-collapsed
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

/anki.tags.TagsService/TagTree

Request: anki.generic.Empty
Response: anki.tags.TagTreeNode

Usage:
  anki_as_code api tags tag-tree [flags]

Flags:
      --backend string         Existing backend TCP endpoint or Unix socket path
      --collection string      Offline .anki2 database or .colpkg archive
  -h, --help                   help for tag-tree
      --input string           Request file, or - for stdin (default "-")
      --input-format string    Request encoding: json or toml (default "json")
      --no-write-back          Disable offline archive write-back
      --output-format string   Response encoding: json or toml (default "json")
      --timeout duration       Input, startup and request timeout (default 30s)
      --write-back             Write offline archives back on close (default true)

1.2 - col

Inspect and manage Anki collections
Inspect and manage Anki collections

Usage:
  anki_as_code col [flags]
  anki_as_code col [command]

Aliases:
  col, collection

Available Commands:
  apply       Reconcile an offline collection in place
  build       Build a new archive from the original and desired text
  export      Export a collection to editable TOML
  plan        Inspect desired collection changes
  state       Inspect and manage collection-backed path bindings

Flags:
  -h, --help               help for col
      --state-key string   Collection state namespace key (default "anki_as_code/state/v1")

Use "anki_as_code col [command] --help" for more information about a command.

Reconcile an offline collection in place

Usage:
  anki_as_code col apply [flags]

Flags:
      --collection string   Anki .colpkg archive or offline .anki2 database
  -h, --help                help for apply
      --text string         Collection root config or its containing directory

Global Flags:
      --state-key string   Collection state namespace key (default "anki_as_code/state/v1")

Build a new archive from the original and desired text

Usage:
  anki_as_code col build [flags]

Flags:
      --base string     Original collection archive
  -h, --help            help for build
      --output string   Destination text directory (export) or collection archive (build)
      --text string     Collection root config or its containing directory

Global Flags:
      --state-key string   Collection state namespace key (default "anki_as_code/state/v1")

Export a collection to editable TOML

Usage:
  anki_as_code col export [flags]

Flags:
      --collection string     Anki .colpkg archive or offline .anki2 database
  -h, --help                  help for export
      --output string         Destination text directory (export) or collection archive (build)
      --state-output string   Optional destination file for exported TOML state bindings

Global Flags:
      --state-key string   Collection state namespace key (default "anki_as_code/state/v1")

Inspect desired collection changes

Usage:
  anki_as_code col plan [flags]

Flags:
      --collection string   Anki .colpkg archive or offline .anki2 database
  -h, --help                help for plan
      --text string         Collection root config or its containing directory

Global Flags:
      --state-key string   Collection state namespace key (default "anki_as_code/state/v1")

Inspect and manage collection-backed path bindings

Usage:
  anki_as_code col state [flags]
  anki_as_code col state [command]

Available Commands:
  dump        Dump the stored state object
  import      Bind external objects to configuration paths
  replace     Replace the whole stored state object
  update      Merge an external state object into stored state

Flags:
      --collection string   Anki .colpkg archive or offline .anki2 database
  -h, --help                help for state

Global Flags:
      --state-key string   Collection state namespace key (default "anki_as_code/state/v1")

Use "anki_as_code col state [command] --help" for more information about a command.

Dump the stored state object

Usage:
  anki_as_code col state dump [flags]

Flags:
      --format string   State format: toml or json (default "toml")
  -h, --help            help for dump

Global Flags:
      --collection string   Anki .colpkg archive or offline .anki2 database
      --state-key string    Collection state namespace key (default "anki_as_code/state/v1")

Bind external objects to configuration paths

Usage:
  anki_as_code col state import PATH=ID [PATH=ID...] [flags]

Flags:
  -h, --help          help for import
      --text string   Collection root config or its containing directory

Global Flags:
      --collection string   Anki .colpkg archive or offline .anki2 database
      --state-key string    Collection state namespace key (default "anki_as_code/state/v1")

Replace the whole stored state object

Usage:
  anki_as_code col state replace [FILE] [flags]

Flags:
      --format string   State format: toml or json (default "toml")
  -h, --help            help for replace

Global Flags:
      --collection string   Anki .colpkg archive or offline .anki2 database
      --state-key string    Collection state namespace key (default "anki_as_code/state/v1")

Merge an external state object into stored state

Usage:
  anki_as_code col state update [FILE] [flags]

Flags:
      --format string   State format: toml or json (default "toml")
  -h, --help            help for update

Global Flags:
      --collection string   Anki .colpkg archive or offline .anki2 database
      --state-key string    Collection state namespace key (default "anki_as_code/state/v1")

1.3 - config

Inspect and manipulate collection configuration files
Inspect and manipulate collection configuration files

Usage:
  anki_as_code config [flags]
  anki_as_code config [command]

Aliases:
  config, conf

Available Commands:
  dump        Print parsed collection configurations
  export      Write a configuration set as TOML files

Flags:
  -h, --help   help for config

Use "anki_as_code config [command] --help" for more information about a command.

Print parsed collection configurations

Usage:
  anki_as_code config dump [flags]

Flags:
      --format string   Output format: json or toml (default "json")
  -h, --help            help for dump
      --text string     Collection root config or its containing directory

Write a configuration set as TOML files

Usage:
  anki_as_code config export [FILE] [flags]

Flags:
      --format string   Input format: json or toml (default "json")
  -h, --help            help for export
      --output string   Destination text directory (export) or collection archive (build)

1.4 - help

Help about any command
Help provides help for any command in the application.
Simply type anki_as_code help [path to command] for full details.

Usage:
  anki_as_code help [command] [flags]

Flags:
  -h, --help   help for help

1.5 - server

Manage the native Anki server
Manage the native Anki server

Usage:
  anki_as_code server [flags]
  anki_as_code server [command]

Available Commands:
  run         Run the linked native Anki CLI
  serve       Run the native Anki gRPC server

Flags:
  -h, --help   help for server

Use "anki_as_code server [command] --help" for more information about a command.

Arguments and flags are forwarded to the native CLI. Run anki_as_code server run --help for native options.

Run the linked native Anki CLI

Usage:
  anki_as_code server run [flags]

Flags:
  -h, --help   help for run

Arguments and flags are forwarded to the native CLI. Run anki_as_code server serve --help for native options.

Run the native Anki gRPC server

Usage:
  anki_as_code server serve [flags]

Flags:
  -h, --help   help for serve