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/whoami on the JsonFabrica gateway using the configured API key. Returns { tenantId, role } for the configured JSONFABRICA_API_KEY.

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 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 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 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 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/{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 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/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 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/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 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 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 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 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/usage. Returns { tenantId, usageTotal, asOf } for the configured API key.