5 - 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.
Native server
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.
Upstream API commands
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.
Onboarding an existing collection
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.
Configuration-set export
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 operations
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 Go API
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.
Collection lifecycle
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 and explicit moves
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.
Managed and unmanaged entities
- 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.
Publication and planning
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.
Fixed hierarchy
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.
Serialization and package APIs
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.
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.
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.
Package dependencies
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.
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 Go API
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)
Archive build Go API
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.
Native resource Go API
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, ¬es.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.
Collection export Go API
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.
Anki backend API
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.
Integration approaches considered
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.
The maintained Mermaid source is rendered by the
:backend_approaches Bazel target and published with the project documentation.
Verification
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.
5.1.1 - api
Invoke upstream Anki services using protobuf JSON or TOML
anki_as_code api
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_as_code api anki-hub
anki.ankihub.AnkiHubService
anki_as_code api ankidroid
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_as_code api ankidroid flush-all-queries
/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_as_code api ankidroid flush-query
/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_as_code api ankidroid get-active-sequence-numbers
/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_as_code api ankidroid get-column-names-from-query
/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_as_code api ankidroid insert-for-id
/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_as_code api ankidroid run-db-command
/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_as_code api ankidroid run-db-command-for-row-count
/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_as_code api ankidroid run-db-command-proto
/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_as_code api ankiweb
anki.ankiweb.AnkiwebService
anki_as_code api backend-anki-hub
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_as_code api backend-anki-hub ankihub-login
/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_as_code api backend-anki-hub ankihub-logout
/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_as_code api backend-ankidroid
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_as_code api backend-ankidroid debug-produce-error
/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_as_code api backend-ankidroid flush-all-queries
/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_as_code api backend-ankidroid flush-query
/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_as_code api backend-ankidroid get-active-sequence-numbers
/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_as_code api backend-ankidroid get-column-names-from-query
/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_as_code api backend-ankidroid insert-for-id
/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_as_code api backend-ankidroid local-minutes-west-legacy
/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_as_code api backend-ankidroid run-db-command
/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_as_code api backend-ankidroid run-db-command-for-row-count
/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_as_code api backend-ankidroid run-db-command-proto
/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_as_code api backend-ankidroid sched-timing-today-legacy
/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_as_code api backend-ankiweb
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_as_code api backend-ankiweb check-for-update
/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_as_code api backend-ankiweb get-addon-info
/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_as_code api backend-card-rendering
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_as_code api backend-card-rendering all-tts-voices
/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_as_code api backend-card-rendering compare-answer
/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_as_code api backend-card-rendering decode-iri-paths
/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_as_code api backend-card-rendering encode-iri-paths
/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_as_code api backend-card-rendering get-empty-cards
/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_as_code api backend-card-rendering render-existing-card
/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_as_code api backend-card-rendering render-markdown
/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_as_code api backend-card-rendering render-uncommitted-card
/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_as_code api backend-card-rendering render-uncommitted-card-legacy
/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_as_code api backend-card-rendering strip-html
/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_as_code api backend-card-rendering write-tts-stream
/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_as_code api backend-cards
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_as_code api backend-cards get-card
/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_as_code api backend-cards remove-cards
/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_as_code api backend-cards set-deck
/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_as_code api backend-cards set-flag
/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_as_code api backend-cards update-cards
/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_as_code api backend-collection
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_as_code api backend-collection await-backup-completion
/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_as_code api backend-collection check-database
/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_as_code api backend-collection close-collection
/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_as_code api backend-collection create-backup
/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_as_code api backend-collection get-custom-colours
/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_as_code api backend-collection get-undo-status
/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_as_code api backend-collection latest-progress
/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_as_code api backend-collection merge-undo-entries
/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_as_code api backend-collection open-collection
/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_as_code api backend-collection redo
/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_as_code api backend-collection set-load-balancer-enabled
/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_as_code api backend-collection set-wants-abort
/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_as_code api backend-collection undo
/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_as_code api backend-config
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_as_code api backend-config get-all-config
/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_as_code api backend-config get-config-bool
/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_as_code api backend-config get-config-json
/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_as_code api backend-config get-config-string
/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_as_code api backend-config get-preferences
/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_as_code api backend-config remove-config
/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_as_code api backend-config set-config-bool
/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_as_code api backend-config set-config-json
/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_as_code api backend-config set-config-json-no-undo
/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_as_code api backend-config set-config-string
/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_as_code api backend-config set-preferences
/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_as_code api backend-deck-config
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_as_code api backend-deck-config add-or-update-deck-config-legacy
/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_as_code api backend-deck-config all-deck-config-legacy
/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_as_code api backend-deck-config get-deck-config
/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_as_code api backend-deck-config get-deck-config-legacy
/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_as_code api backend-deck-config get-deck-configs-for-update
/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_as_code api backend-deck-config get-ignored-before-count
/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_as_code api backend-deck-config get-retention-workload
/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_as_code api backend-deck-config new-deck-config-legacy
/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_as_code api backend-deck-config remove-deck-config
/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_as_code api backend-deck-config update-deck-configs
/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_as_code api backend-decks
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_as_code api backend-decks add-deck
/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_as_code api backend-decks add-deck-legacy
/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_as_code api backend-decks add-or-update-deck-legacy
/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_as_code api backend-decks add-or-update-filtered-deck
/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_as_code api backend-decks deck-tree
/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_as_code api backend-decks deck-tree-legacy
/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_as_code api backend-decks filtered-deck-order-labels
/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_as_code api backend-decks get-all-decks-legacy
/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_as_code api backend-decks get-current-deck
/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_as_code api backend-decks get-deck
/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_as_code api backend-decks get-deck-and-child-names
/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_as_code api backend-decks get-deck-id-by-name
/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_as_code api backend-decks get-deck-legacy
/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_as_code api backend-decks get-deck-names
/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_as_code api backend-decks get-or-create-filtered-deck
/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_as_code api backend-decks new-deck
/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_as_code api backend-decks new-deck-legacy
/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_as_code api backend-decks remove-decks
/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_as_code api backend-decks rename-deck
/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_as_code api backend-decks reparent-decks
/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_as_code api backend-decks set-current-deck
/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_as_code api backend-decks set-deck-collapsed
/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_as_code api backend-decks update-deck
/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_as_code api backend-decks update-deck-legacy
/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_as_code api backend-frontend
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_as_code api backend-frontend ask-user
/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_as_code api backend-frontend close-add-cards
/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_as_code api backend-frontend close-edit-current
/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_as_code api backend-frontend convert-pasted-image
/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_as_code api backend-frontend deck-options-ready
/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_as_code api backend-frontend deck-options-require-close
/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_as_code api backend-frontend get-profile-config-json
/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_as_code api backend-frontend get-scheduling-states-with-context
/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_as_code api backend-frontend import-dialog-require-close
/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_as_code api backend-frontend import-done
/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_as_code api backend-frontend open-cards-dialog
/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_as_code api backend-frontend open-fields-dialog
/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_as_code api backend-frontend open-file-picker
/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_as_code api backend-frontend open-link
/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_as_code api backend-frontend play-file
/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_as_code api backend-frontend read-clipboard
/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_as_code api backend-frontend record-audio
/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_as_code api backend-frontend save-custom-colours
/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_as_code api backend-frontend search-in-browser
/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_as_code api backend-frontend set-profile-config-json
/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_as_code api backend-frontend set-scheduling-states
/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_as_code api backend-frontend show-message-box
/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_as_code api backend-frontend write-clipboard
/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_as_code api backend-github
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_as_code api backend-github download-release
/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_as_code api backend-github get-latest-release
/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_as_code api backend-i18n
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_as_code api backend-i18n i18n-resources
/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_as_code api backend-i18n translate-string
/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_as_code api backend-image-occlusion
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_as_code api backend-image-occlusion add-image-occlusion-note
/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_as_code api backend-image-occlusion add-image-occlusion-notetype
/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_as_code api backend-image-occlusion get-image-for-occlusion
/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_as_code api backend-image-occlusion get-image-occlusion-fields
/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_as_code api backend-image-occlusion get-image-occlusion-note
/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_as_code api backend-image-occlusion update-image-occlusion-note
/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_as_code api backend-import-export
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_as_code api backend-import-export export-anki-package
/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_as_code api backend-import-export export-card-csv
/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_as_code api backend-import-export export-collection-package
/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_as_code api backend-import-export export-note-csv
/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_as_code api backend-import-export get-import-anki-package-presets
/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_as_code api backend-import-export import-anki-package
/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_as_code api backend-import-export import-collection-package
/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_as_code api backend-import-export import-csv
/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_as_code api backend-import-export import-json-file
/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_as_code api backend-import-export import-json-string
/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_as_code api backend-links
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_as_code api backend-notes
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_as_code api backend-notes add-note
/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_as_code api backend-notes add-notes
/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_as_code api backend-notes after-note-updates
/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_as_code api backend-notes cards-of-note
/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_as_code api backend-notes cloze-numbers-in-note
/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_as_code api backend-notes default-deck-for-notetype
/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_as_code api backend-notes defaults-for-adding
/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_as_code api backend-notes field-names-for-notes
/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_as_code api backend-notes get-note
/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_as_code api backend-notes get-single-notetype-of-notes
/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_as_code api backend-notes new-note
/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_as_code api backend-notes note-fields-check
/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_as_code api backend-notes remove-notes
/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_as_code api backend-notes update-notes
/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_as_code api backend-notetypes
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_as_code api backend-notetypes add-notetype
/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_as_code api backend-notetypes add-notetype-legacy
/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_as_code api backend-notetypes add-or-update-notetype
/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_as_code api backend-notetypes change-notetype
/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_as_code api backend-notetypes get-aux-notetype-config-key
/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_as_code api backend-notetypes get-aux-template-config-key
/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_as_code api backend-notetypes get-change-notetype-info
/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_as_code api backend-notetypes get-cloze-field-ords
/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_as_code api backend-notetypes get-field-names
/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_as_code api backend-notetypes get-notetype
/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_as_code api backend-notetypes get-notetype-id-by-name
/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_as_code api backend-notetypes get-notetype-legacy
/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_as_code api backend-notetypes get-notetype-names
/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_as_code api backend-notetypes get-notetype-names-and-counts
/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_as_code api backend-notetypes get-stock-notetype-legacy
/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_as_code api backend-notetypes remove-notetype
/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_as_code api backend-notetypes restore-notetype-to-stock
/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_as_code api backend-notetypes update-notetype
/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_as_code api backend-notetypes update-notetype-legacy
/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_as_code api backend-scheduler
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_as_code api backend-scheduler answer-card
/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_as_code api backend-scheduler bury-or-suspend-cards
/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_as_code api backend-scheduler compute-fsrs-params
/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_as_code api backend-scheduler compute-fsrs-params-from-items
/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_as_code api backend-scheduler compute-memory-state
/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_as_code api backend-scheduler compute-optimal-retention
/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_as_code api backend-scheduler congrats-info
/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_as_code api backend-scheduler counts-for-deck-today
/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_as_code api backend-scheduler custom-study
/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_as_code api backend-scheduler custom-study-defaults
/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_as_code api backend-scheduler describe-next-states
/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_as_code api backend-scheduler empty-filtered-deck
/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_as_code api backend-scheduler evaluate-params
/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_as_code api backend-scheduler evaluate-params-legacy
/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_as_code api backend-scheduler export-dataset
/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_as_code api backend-scheduler extend-limits
/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_as_code api backend-scheduler fsrs-benchmark
/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_as_code api backend-scheduler fuzz-delta
/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_as_code api backend-scheduler get-optimal-retention-parameters
/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_as_code api backend-scheduler get-queued-cards
/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_as_code api backend-scheduler get-scheduling-states
/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_as_code api backend-scheduler grade-now
/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_as_code api backend-scheduler rebuild-filtered-deck
/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_as_code api backend-scheduler reposition-defaults
/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_as_code api backend-scheduler restore-buried-and-suspended-cards
/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_as_code api backend-scheduler sched-timing-today
/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_as_code api backend-scheduler schedule-cards-as-new
/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_as_code api backend-scheduler schedule-cards-as-new-defaults
/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_as_code api backend-scheduler set-due-date
/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_as_code api backend-scheduler simulate-fsrs-review
/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_as_code api backend-scheduler simulate-fsrs-workload
/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_as_code api backend-scheduler sort-cards
/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_as_code api backend-scheduler sort-deck
/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_as_code api backend-scheduler state-is-leech
/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_as_code api backend-scheduler studied-today
/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_as_code api backend-scheduler studied-today-message
/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_as_code api backend-scheduler unbury-deck
/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_as_code api backend-scheduler update-stats
/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_as_code api backend-scheduler upgrade-scheduler
/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_as_code api backend-search
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_as_code api backend-search all-browser-columns
/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_as_code api backend-search browser-row-for-id
/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_as_code api backend-search build-search-string
/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_as_code api backend-search find-and-replace
/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_as_code api backend-search join-search-nodes
/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_as_code api backend-search replace-search-node
/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_as_code api backend-search search-cards
/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_as_code api backend-search search-notes
/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_as_code api backend-search set-active-browser-columns
/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_as_code api backend-stats
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_as_code api backend-stats card-stats
/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_as_code api backend-stats get-graph-preferences
/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_as_code api backend-stats get-review-logs
/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_as_code api backend-stats graphs
/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_as_code api backend-stats set-graph-preferences
/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_as_code api backend-sync
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_as_code api backend-sync abort-sync
/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_as_code api backend-sync full-upload-or-download
/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_as_code api backend-sync set-custom-certificate
/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_as_code api backend-sync sync-collection
/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_as_code api backend-sync sync-login
/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_as_code api backend-sync sync-status
/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_as_code api card-rendering
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_as_code api card-rendering compare-answer
/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_as_code api card-rendering decode-iri-paths
/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_as_code api card-rendering encode-iri-paths
/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_as_code api card-rendering get-empty-cards
/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_as_code api card-rendering render-existing-card
/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_as_code api card-rendering render-markdown
/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_as_code api card-rendering render-uncommitted-card
/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_as_code api card-rendering render-uncommitted-card-legacy
/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_as_code api card-rendering strip-html
/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_as_code api cards
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_as_code api cards get-card
/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_as_code api cards remove-cards
/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_as_code api cards set-deck
/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_as_code api cards set-flag
/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_as_code api cards update-cards
/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_as_code api collection
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_as_code api collection check-database
/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_as_code api collection get-custom-colours
/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_as_code api collection get-undo-status
/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_as_code api collection latest-progress
/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_as_code api collection merge-undo-entries
/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_as_code api collection redo
/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_as_code api collection set-load-balancer-enabled
/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_as_code api collection set-wants-abort
/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_as_code api collection undo
/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_as_code api config
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_as_code api config get-all-config
/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_as_code api config get-config-bool
/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_as_code api config get-config-json
/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_as_code api config get-config-string
/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_as_code api config get-preferences
/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_as_code api config remove-config
/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_as_code api config set-config-bool
/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_as_code api config set-config-json
/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_as_code api config set-config-json-no-undo
/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_as_code api config set-config-string
/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_as_code api config set-preferences
/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_as_code api deck-config
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_as_code api deck-config add-or-update-deck-config-legacy
/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_as_code api deck-config all-deck-config-legacy
/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_as_code api deck-config get-deck-config
/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_as_code api deck-config get-deck-config-legacy
/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_as_code api deck-config get-deck-configs-for-update
/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_as_code api deck-config get-ignored-before-count
/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_as_code api deck-config get-retention-workload
/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_as_code api deck-config new-deck-config-legacy
/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_as_code api deck-config remove-deck-config
/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_as_code api deck-config update-deck-configs
/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_as_code api decks
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_as_code api decks add-deck
/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_as_code api decks add-deck-legacy
/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_as_code api decks add-or-update-deck-legacy
/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_as_code api decks add-or-update-filtered-deck
/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_as_code api decks deck-tree
/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_as_code api decks deck-tree-legacy
/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_as_code api decks filtered-deck-order-labels
/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_as_code api decks get-all-decks-legacy
/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_as_code api decks get-current-deck
/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_as_code api decks get-deck
/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_as_code api decks get-deck-and-child-names
/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_as_code api decks get-deck-id-by-name
/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_as_code api decks get-deck-legacy
/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_as_code api decks get-deck-names
/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_as_code api decks get-or-create-filtered-deck
/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_as_code api decks new-deck
/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_as_code api decks new-deck-legacy
/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_as_code api decks remove-decks
/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_as_code api decks rename-deck
/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_as_code api decks reparent-decks
/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_as_code api decks set-current-deck
/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_as_code api decks set-deck-collapsed
/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_as_code api decks update-deck
/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_as_code api decks update-deck-legacy
/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_as_code api frontend
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_as_code api frontend ask-user
/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_as_code api frontend close-add-cards
/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_as_code api frontend close-edit-current
/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_as_code api frontend convert-pasted-image
/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_as_code api frontend deck-options-ready
/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_as_code api frontend deck-options-require-close
/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_as_code api frontend get-profile-config-json
/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_as_code api frontend get-scheduling-states-with-context
/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_as_code api frontend import-dialog-require-close
/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_as_code api frontend import-done
/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_as_code api frontend open-cards-dialog
/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_as_code api frontend open-fields-dialog
/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_as_code api frontend open-file-picker
/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_as_code api frontend open-link
/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_as_code api frontend play-file
/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_as_code api frontend read-clipboard
/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_as_code api frontend record-audio
/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_as_code api frontend save-custom-colours
/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_as_code api frontend search-in-browser
/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_as_code api frontend set-profile-config-json
/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_as_code api frontend set-scheduling-states
/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_as_code api frontend show-message-box
/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_as_code api frontend write-clipboard
/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_as_code api github
anki.github.GithubService
anki_as_code api i18n
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_as_code api i18n i18n-resources
/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_as_code api i18n translate-string
/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_as_code api image-occlusion
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_as_code api image-occlusion add-image-occlusion-note
/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_as_code api image-occlusion add-image-occlusion-notetype
/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_as_code api image-occlusion get-image-for-occlusion
/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_as_code api image-occlusion get-image-occlusion-fields
/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_as_code api image-occlusion get-image-occlusion-note
/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_as_code api image-occlusion update-image-occlusion-note
/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_as_code api import-export
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_as_code api import-export export-anki-package
/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_as_code api import-export export-card-csv
/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_as_code api import-export export-note-csv
/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_as_code api import-export get-import-anki-package-presets
/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_as_code api import-export import-anki-package
/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_as_code api import-export import-csv
/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_as_code api import-export import-json-file
/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_as_code api import-export import-json-string
/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_as_code api links
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_as_code api notes
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_as_code api notes add-note
/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_as_code api notes add-notes
/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_as_code api notes after-note-updates
/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_as_code api notes cards-of-note
/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_as_code api notes cloze-numbers-in-note
/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_as_code api notes default-deck-for-notetype
/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_as_code api notes defaults-for-adding
/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_as_code api notes field-names-for-notes
/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_as_code api notes get-note
/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_as_code api notes get-single-notetype-of-notes
/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_as_code api notes new-note
/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_as_code api notes note-fields-check
/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_as_code api notes remove-notes
/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_as_code api notes update-notes
/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_as_code api notetypes
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_as_code api notetypes add-notetype
/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_as_code api notetypes add-notetype-legacy
/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_as_code api notetypes add-or-update-notetype
/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_as_code api notetypes change-notetype
/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_as_code api notetypes get-aux-notetype-config-key
/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_as_code api notetypes get-aux-template-config-key
/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_as_code api notetypes get-change-notetype-info
/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_as_code api notetypes get-cloze-field-ords
/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_as_code api notetypes get-field-names
/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_as_code api notetypes get-notetype
/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_as_code api notetypes get-notetype-id-by-name
/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_as_code api notetypes get-notetype-legacy
/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_as_code api notetypes get-notetype-names
/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_as_code api notetypes get-notetype-names-and-counts
/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_as_code api notetypes get-stock-notetype-legacy
/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_as_code api notetypes remove-notetype
/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_as_code api notetypes restore-notetype-to-stock
/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_as_code api notetypes update-notetype
/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_as_code api notetypes update-notetype-legacy
/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_as_code api scheduler
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_as_code api scheduler answer-card
/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_as_code api scheduler bury-or-suspend-cards
/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_as_code api scheduler compute-fsrs-params
/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_as_code api scheduler compute-memory-state
/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_as_code api scheduler compute-optimal-retention
/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_as_code api scheduler congrats-info
/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_as_code api scheduler counts-for-deck-today
/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_as_code api scheduler custom-study
/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_as_code api scheduler custom-study-defaults
/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_as_code api scheduler describe-next-states
/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_as_code api scheduler empty-filtered-deck
/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_as_code api scheduler evaluate-params
/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_as_code api scheduler evaluate-params-legacy
/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_as_code api scheduler extend-limits
/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_as_code api scheduler fuzz-delta
/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_as_code api scheduler get-optimal-retention-parameters
/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_as_code api scheduler get-queued-cards
/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_as_code api scheduler get-scheduling-states
/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_as_code api scheduler grade-now
/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_as_code api scheduler rebuild-filtered-deck
/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_as_code api scheduler reposition-defaults
/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_as_code api scheduler restore-buried-and-suspended-cards
/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_as_code api scheduler sched-timing-today
/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_as_code api scheduler schedule-cards-as-new
/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_as_code api scheduler schedule-cards-as-new-defaults
/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_as_code api scheduler set-due-date
/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_as_code api scheduler simulate-fsrs-review
/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_as_code api scheduler simulate-fsrs-workload
/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_as_code api scheduler sort-cards
/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_as_code api scheduler sort-deck
/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_as_code api scheduler state-is-leech
/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_as_code api scheduler studied-today
/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_as_code api scheduler studied-today-message
/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_as_code api scheduler unbury-deck
/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_as_code api scheduler update-stats
/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_as_code api scheduler upgrade-scheduler
/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_as_code api search
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_as_code api search all-browser-columns
/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_as_code api search browser-row-for-id
/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_as_code api search build-search-string
/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_as_code api search find-and-replace
/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_as_code api search join-search-nodes
/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_as_code api search replace-search-node
/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_as_code api search search-cards
/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_as_code api search search-notes
/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_as_code api search set-active-browser-columns
/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_as_code api stats
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_as_code api stats card-stats
/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_as_code api stats get-graph-preferences
/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_as_code api stats get-review-logs
/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_as_code api stats graphs
/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_as_code api stats set-graph-preferences
/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_as_code api sync
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)
