JsonFabrica

Calls POST /v1/sequences/{name}/bump. Atomically advances the sequence by its configured `step` (a permanent, irreversible change to the stored `currentValue`) and returns the updated record — this is the same advance a template's createSeq()/getSeq() calls trigger during generation. Use jsonfabrica_update_sequence instead if you need to set an explicit `currentValue`/`step` rather than advancing by the existing step.

Calls POST /v1/batches. Generates multiple documents from one or more persisted templates in one call, optionally cross-referencing documents via `relations` — use this instead of looping jsonfabrica_generate_from_template yourself when you need many documents or cross-document relations in a single request. Small batches run synchronously and the response is 200 with `results`; larger batches are queued and the response is 202 with just `{ batchId, status, seed }` — poll jsonfabrica_get_batch for the final results in that case. Like a single generate call, this is metered/billed per document produced and, unless namespaced, can advance real durable sequences and mutate durable variables referenced by the templates.

Calls POST /v1/sequences. Creates a durable named sequence (number/string/uuid), referenced from template bodies via createSeq()/getSeq()-style functions. Fails with a 409-style conflict error if a sequence with this `name` already exists for the tenant — use jsonfabrica_update_sequence to change an existing one's `currentValue`/`step` instead of retrying create with the same name.

Calls POST /v1/templates. Creates a persisted, reusable template that can be generated from repeatedly with jsonfabrica_generate_from_template — use this instead of jsonfabrica_generate_adhoc when you want the body saved and shareable rather than a one-off, unsaved evaluation. `body` uses JsonFabrica's function-call placeholder syntax, e.g. "Hello {{getRandomFullName()}}" or "<getRandomNumber(1,100)>" — see the data-generation-functions reference for the full catalog. The optional `generate` field is a convenience that also runs a generation in the same call (response includes `generation` or `generationError` alongside `template`) so you avoid a separate jsonfabrica_generate_from_template round-trip; that generation is metered/billed and can advance durable sequences/variables just like a normal generate call. If `generate` is omitted, the response is just the created template with no generation side effects.

Calls DELETE /v1/sequences/{name}. This is a hard, permanent delete — unlike jsonfabrica_delete_template's soft-delete/archive behavior, the sequence record is removed entirely and cannot be recovered; there is no `status: "archived"` equivalent for sequences. Returns no content on success. Any template body still calling createSeq()/getSeq() with this `name` afterwards will no longer see the deleted history/state.

Calls DELETE /v1/templates/{templateId}. This is a soft delete: the template's `status` is set to "archived" (it is not erased from storage), and the call returns the resulting archived template record. Archived templates are excluded from jsonfabrica_list_templates by default — pass `status: "archived"` there to find them again — and both jsonfabrica_get_template and jsonfabrica_generate_from_template still work against the id afterwards, since archiving does not block reads or generation. Use this when a template should stop showing up in normal listings; there is currently no tool to restore an archived template back to `active`.

Calls POST /v1/templates/generate. Generates a document directly from a raw `body` string without creating a template record — prefer this over jsonfabrica_generate_from_template while still iterating on template syntax; switch to jsonfabrica_create_template once the body is ready to be reused or shared. Goes through the same billing/usage metering as persisted-template generation (not a free bypass). createSeq()/durable sequence side effects still apply; set `sequenceNamespace`/`variableNamespace` to e.g. "debug" to avoid colliding with real tenant sequences and variables.

Calls POST /v1/templates/{templateId}/generate. Generates a document from a persisted, saved template referenced by `templateId` — use this (not jsonfabrica_generate_adhoc) when the template is meant to be reused or shared across calls/tenants; use jsonfabrica_generate_adhoc instead when you are still iterating on raw template syntax and don't want to persist anything yet. This call is metered/billed like any generation and, unless namespaced, can advance real durable sequences and mutate durable variables referenced by the template body. Set `sequenceNamespace`/`variableNamespace` to isolate those side effects between environments (e.g. test vs. production).

Calls GET /v1/batches/{batchId}. Returns batch status and, once complete, the generated documents. Use this to poll a batch that was accepted asynchronously (202).

Calls GET /v1/sequences/{name}. Returns the sequence record for a known `name`; use jsonfabrica_list_sequences instead if you need to discover names. Read-only — does not advance the sequence (use jsonfabrica_bump_sequence for that).

Calls GET /v1/templates/{templateId}. Returns the full template record for a known id. Use this instead of jsonfabrica_list_templates when you already have the `templateId` (e.g. from a prior create/list call); it is also the recommended way to inspect current `body`/`tags`/`description` before calling jsonfabrica_update_template, since update only shows you the fields you send, not the result of merging them with what already exists. Read-only, no side effects.

Calls GET /v1/usage. Returns `{ tenantId, usageTotal, asOf }` for the configured API key.

Calls GET /health on the JsonFabrica gateway. No authentication required. Use this to verify JSONFABRICA_API_URL points at a reachable gateway.

Calls GET /v1/sequences. Returns a page of sequences (`{ items, nextCursor }`). Use this to discover sequence names when you don't already know one; if you know the exact `name`, call jsonfabrica_get_sequence directly instead. Read-only, no side effects.

Calls GET /v1/templates. Returns a page of templates matching optional `name`/`tags`/`status` filters (`{ items, nextCursor }`). Use this to discover or search templates when you don't already know the `templateId`; if you already have the id, call jsonfabrica_get_template directly instead — it is cheaper and returns the full record. This is read-only and has no side effects. Pass `status: "archived"` to see templates previously removed with jsonfabrica_delete_template, since the default `active` filter excludes them.

Calls PATCH /v1/sequences/{name}. Only the provided fields (currentValue, step) are changed; fields you omit are left as-is. Use this when you need to set an explicit `currentValue` (e.g. resetting a counter) or change the `step` amount — use jsonfabrica_bump_sequence instead when you just want to advance the sequence by its existing configured step. This overwrites the sequence's stored state in place immediately; there is no undo.

Calls PUT /v1/templates/{templateId}. Partially updates an existing template in place: only the fields you include in the call are changed, and every field you omit is left exactly as it was — call jsonfabrica_get_template first if you need to see current values before deciding what to send. Use this only for an existing `templateId`; to make a new template use jsonfabrica_create_template instead (it does not modify or version the original). The change is applied immediately and in-place with no version history — there is no undo, so if you need to keep the old `body`/`tags` around, read and save them first.

Calls GET /v1/whoami on the JsonFabrica gateway using the configured API key. Returns { tenantId, role } for the configured JSONFABRICA_API_KEY.