zinkee 0.1.23 → 0.1.24

package/dist/index.js

@@ -436,6 +436,62 @@ var commandRegistry = {
     supportsRaw: false,
     output: writeOutput
   },
+  "document-templates list": {
+    command: "document-templates list",
+    accessLevel: "read",
+    supportsExample: true,
+    supportsRaw: false,
+    output: readOutput
+  },
+  "document-templates get": {
+    command: "document-templates get",
+    accessLevel: "read",
+    supportsExample: true,
+    supportsRaw: false,
+    output: readOutput
+  },
+  "document-templates create": {
+    command: "document-templates create",
+    accessLevel: "write",
+    supportsExample: true,
+    supportsRaw: true,
+    output: writeOutput
+  },
+  "document-templates update": {
+    command: "document-templates update",
+    accessLevel: "write",
+    supportsExample: true,
+    supportsRaw: false,
+    output: writeOutput
+  },
+  "document-templates delete": {
+    command: "document-templates delete",
+    accessLevel: "destructive",
+    supportsExample: true,
+    supportsRaw: false,
+    output: writeOutput
+  },
+  "document-templates assets add": {
+    command: "document-templates assets add",
+    accessLevel: "write",
+    supportsExample: true,
+    supportsRaw: false,
+    output: writeOutput
+  },
+  "document-templates assets delete": {
+    command: "document-templates assets delete",
+    accessLevel: "destructive",
+    supportsExample: true,
+    supportsRaw: false,
+    output: writeOutput
+  },
+  "document-templates assets download": {
+    command: "document-templates assets download",
+    accessLevel: "read",
+    supportsExample: true,
+    supportsRaw: false,
+    output: "binary"
+  },
   "files upload": {
     command: "files upload",
     accessLevel: "write",
@@ -5721,6 +5777,171 @@ var specificExamples = {
   "isRoot": false
 }`
     }
+  ]),
+  "document-templates list": buildCommandExamples([
+    {
+      description: "List every document template in the workspace. Each asset's link is a relative path to the asset download endpoint, ready to call without composition.",
+      command: "zinkee --json document-templates list",
+      response: `[
+  {
+    "id": "7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e",
+    "name": "Quarterly report",
+    "assets": [
+      {
+        "id": "9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f",
+        "name": "Requirements.docx",
+        "link": "/api/v2/document-templates/7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e/assets/9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f/download"
+      }
+    ],
+    "createdAt": "2026-01-15T10:00:00Z",
+    "updatedAt": "2026-01-20T14:30:00Z",
+    "createdBy": "creator@example.com",
+    "updatedBy": "updater@example.com"
+  }
+]`
+    }
+  ]),
+  "document-templates get": buildCommandExamples([
+    {
+      description: "Look up one template by UUID. The CLI filters the list endpoint locally (the backend does not expose a get-one route).",
+      command: "zinkee --json document-templates get 7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e",
+      response: `{
+  "id": "7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e",
+  "name": "Quarterly report",
+  "assets": [
+    {
+      "id": "9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f",
+      "name": "Requirements.docx",
+      "link": "/api/v2/document-templates/7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e/assets/9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f/download"
+    }
+  ],
+  "createdAt": "2026-01-15T10:00:00Z",
+  "updatedAt": "2026-01-20T14:30:00Z",
+  "createdBy": "creator@example.com",
+  "updatedBy": "creator@example.com"
+}`
+    },
+    {
+      description: "Look up by exact template name. Names are unique within the workspace; ambiguity is reported as an error.",
+      command: 'zinkee --json document-templates get "Quarterly report"'
+    }
+  ]),
+  "document-templates create": buildCommandExamples([
+    {
+      description: "Typical create: empty template by name. Assets are uploaded afterwards via document-templates assets add.",
+      command: 'zinkee --json document-templates create --name "Quarterly report"',
+      raw: `{
+  "name": "Quarterly report",
+  "assets": []
+}`,
+      response: `{
+  "id": "7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e",
+  "name": "Quarterly report",
+  "assets": [],
+  "createdAt": "2026-01-15T10:00:00Z",
+  "updatedAt": "2026-01-15T10:00:00Z",
+  "createdBy": "creator@example.com",
+  "updatedBy": "creator@example.com"
+}`
+    },
+    {
+      description: "Create with pre-existing asset records via --raw. Used for import/migration flows where the assets already exist elsewhere; the typical UX is to create empty and upload via assets add.",
+      command: `zinkee --json document-templates create --raw '{"name":"Annual report","assets":[{"id":"9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f","name":"Cover.docx","link":"/existing/cover.docx"},{"id":"3f2e1d0c-9b8a-7654-3210-fedcba987654","name":"Appendix.docx","link":"/existing/appendix.docx"}]}'`,
+      raw: `{
+  "name": "Annual report",
+  "assets": [
+    {
+      "id": "9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f",
+      "name": "Cover.docx",
+      "link": "/existing/cover.docx"
+    },
+    {
+      "id": "3f2e1d0c-9b8a-7654-3210-fedcba987654",
+      "name": "Appendix.docx",
+      "link": "/existing/appendix.docx"
+    }
+  ]
+}`
+    }
+  ]),
+  "document-templates update": buildCommandExamples([
+    {
+      description: "Rename a template. The template argument accepts a UUID or an exact current name. Only the name is updatable through this endpoint; assets are managed via the assets subcommands.",
+      command: 'zinkee --json document-templates update "Quarterly report" --name "Annual report"',
+      raw: `{
+  "name": "Annual report"
+}`,
+      response: `{
+  "id": "7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e",
+  "name": "Annual report",
+  "assets": [
+    {
+      "id": "9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f",
+      "name": "Requirements.docx",
+      "link": "/api/v2/document-templates/7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e/assets/9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f/download"
+    }
+  ],
+  "createdAt": "2026-01-15T10:00:00Z",
+  "updatedAt": "2026-01-22T09:15:00Z",
+  "createdBy": "creator@example.com",
+  "updatedBy": "updater@example.com"
+}`
+    }
+  ]),
+  "document-templates delete": buildCommandExamples([
+    {
+      description: "Delete a template and remove its asset files from storage. Record fields that reference previously generated documents are not modified.",
+      command: "zinkee --json document-templates delete 7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e",
+      response: `{
+  "id": "7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e",
+  "deleted": true
+}`
+    }
+  ]),
+  "document-templates assets add": buildCommandExamples([
+    {
+      description: 'Upload a local file as an asset of a template. The CLI sends a multipart form with a part named "file"; the asset display name defaults to the uploaded filename.',
+      command: 'zinkee --json document-templates assets add "Quarterly report" ./contract.docx',
+      response: `{
+  "id": "7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e",
+  "name": "Quarterly report",
+  "assets": [
+    {
+      "id": "9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f",
+      "name": "contract.docx",
+      "link": "/api/v2/document-templates/7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e/assets/9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f/download"
+    }
+  ],
+  "createdAt": "2026-01-15T10:00:00Z",
+  "updatedAt": "2026-01-22T09:15:00Z",
+  "createdBy": "creator@example.com",
+  "updatedBy": "updater@example.com"
+}`
+    },
+    {
+      description: "Override the asset display name with --name (otherwise the uploaded filename is used).",
+      command: 'zinkee --json document-templates assets add "Quarterly report" ./contract.docx --name "Customer Contract"'
+    }
+  ]),
+  "document-templates assets delete": buildCommandExamples([
+    {
+      description: "Delete one asset from a template and remove its file from storage.",
+      command: "zinkee --json document-templates assets delete 7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e 9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f",
+      response: `{
+  "id": "9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f",
+  "deleted": true
+}`
+    }
+  ]),
+  "document-templates assets download": buildCommandExamples([
+    {
+      description: "Download asset bytes to disk. The CLI streams the raw bytes to --output; in --json mode --output is required and the JSON envelope only carries metadata.",
+      command: "zinkee --json document-templates assets download 7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e 9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f --output ./contract.docx"
+    },
+    {
+      description: "Stream asset bytes to stdout (omit --json and --output). Useful for piping into other tools.",
+      command: "zinkee document-templates assets download 7c4a8d3f-1b2e-4a5c-9d6e-1f2a3b4c5d6e 9e8d7c6b-5a4f-3e2d-1c0b-9a8b7c6d5e4f > contract.docx"
+    }
   ])
 };
 function fallbackExamples(commandName) {
@@ -5840,7 +6061,7 @@ ${index + 1}. ${example.description}
 
 // src/program.ts
 import { createRequire } from "module";
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 
 // src/config.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -6601,11 +6822,11 @@ function hasSetPath(target, path) {
     return Object.hasOwn(target, path);
   }
   let current = target;
-  for (const segment3 of segments) {
-    if (!isJsonObject2(current) || !Object.hasOwn(current, segment3)) {
+  for (const segment4 of segments) {
+    if (!isJsonObject2(current) || !Object.hasOwn(current, segment4)) {
       return false;
     }
-    current = current[segment3];
+    current = current[segment4];
   }
   return true;
 }
@@ -8749,40 +8970,72 @@ function registerDisplaysCommands(program, options = {}) {
   });
 }
 
-// src/commands/files.ts
+// src/commands/document-templates.ts
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
 import { basename } from "path";
 import { InvalidArgumentError as InvalidArgumentError4 } from "commander";
 
-// src/api/files.ts
+// src/api/document-templates.ts
+function jsonOptions4(body, method) {
+  return {
+    method,
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  };
+}
 function selectorValue4(selector) {
-  return selector.value;
+  return encodeURIComponent(selector.value);
 }
-var FilesApi = class {
+function segment3(value) {
+  return encodeURIComponent(value);
+}
+var DocumentTemplatesApi = class {
   constructor(client) {
     this.client = client;
   }
-  uploadFile(input) {
-    return this.client.requestJson("/api/v2/files", {
-      method: "POST",
-      body: input
-    });
+  listTemplates() {
+    return this.client.getJson("/api/v2/document-templates");
   }
-  downloadFile(file) {
-    return this.client.requestBinary(`/api/v2/files/${selectorValue4(file)}`);
+  createTemplate(input) {
+    return this.client.requestJson(
+      "/api/v2/document-templates",
+      jsonOptions4(input, "POST")
+    );
   }
-  deleteFile(file) {
+  updateTemplate(template, input) {
+    return this.client.requestJson(
+      `/api/v2/document-templates/${selectorValue4(template)}`,
+      jsonOptions4(input, "PATCH")
+    );
+  }
+  deleteTemplate(template) {
     return this.client.requestJson(
-      `/api/v2/files/${selectorValue4(file)}`,
+      `/api/v2/document-templates/${selectorValue4(template)}`,
       { method: "DELETE" }
     );
   }
-  getStorageInfo() {
-    return this.client.getJson("/api/v2/files/storage-info");
+  addAsset(template, input) {
+    return this.client.requestJson(
+      `/api/v2/document-templates/${selectorValue4(template)}/assets`,
+      { method: "POST", body: input }
+    );
+  }
+  deleteAsset(template, assetId) {
+    return this.client.requestJson(
+      `/api/v2/document-templates/${selectorValue4(template)}/assets/${segment3(assetId)}`,
+      { method: "DELETE" }
+    );
+  }
+  downloadAsset(template, assetId) {
+    return this.client.requestBinary(
+      `/api/v2/document-templates/${selectorValue4(template)}/assets/${segment3(assetId)}/download`
+    );
   }
 };
 
-// src/commands/files.ts
+// src/commands/document-templates.ts
 function getCommandIo5(stdout) {
   return stdout ?? process.stdout;
 }
@@ -8814,7 +9067,7 @@ function toConfigurationError5(filePath, error) {
   }
   throw error;
 }
-function createFilesApi(command, filePath) {
+function createDocumentTemplatesApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
     const runtime = resolveRuntimeContext(config, getGlobalOptions5(command));
@@ -8825,7 +9078,7 @@ function createFilesApi(command, filePath) {
       );
     }
     return {
-      api: new FilesApi(
+      api: new DocumentTemplatesApi(
         new ApiClient({
           baseUrl: runtime.baseUrl,
           apiKey: runtime.apiKey
@@ -8858,9 +9111,57 @@ function parseUuidOrSlugSelector4(input) {
     throw new InvalidArgumentError4(message);
   }
 }
-function isRecord3(value) {
+function isJsonObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isEmptyObject4(value) {
+  return Object.keys(value).length === 0;
+}
+function parseJsonValue2(input, sourceLabel) {
+  try {
+    return JSON.parse(input);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid JSON.";
+    throw new CliError(
+      "invalid_cli_usage",
+      `Failed to parse JSON from ${sourceLabel}: ${message}`
+    );
+  }
+}
+function readTextFile2(filePath, label) {
+  try {
+    return readFileSync5(filePath, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unable to read file.";
+    throw new CliError(
+      "invalid_cli_usage",
+      `Failed to read ${label} from ${filePath}: ${message}`
+    );
+  }
+}
+function readJsonObjectOption2(raw, rawFile, rawLabel, rawFileLabel) {
+  if (raw && rawFile) {
+    throw new CliError(
+      "invalid_cli_usage",
+      `Provide either "${rawLabel}" or "${rawFileLabel}", not both.`
+    );
+  }
+  let parsed;
+  if (raw) {
+    parsed = parseJsonValue2(raw, rawLabel);
+  } else if (rawFile) {
+    parsed = parseJsonValue2(readTextFile2(rawFile, rawFileLabel), `${rawFileLabel} ${rawFile}`);
+  } else {
+    return {};
+  }
+  if (!isJsonObject4(parsed)) {
+    throw new CliError(
+      "invalid_cli_usage",
+      `Expected ${raw ? rawLabel : rawFileLabel} to contain a JSON object.`
+    );
+  }
+  return parsed;
+}
 function readLocalFile(filePath) {
   try {
     return readFileSync5(filePath);
@@ -8880,25 +9181,348 @@ function writeDownloadedFile(outputPath, value) {
     );
   }
 }
-function registerFilesCommands(program, options = {}) {
+function templateRows(templates) {
+  return templates.map((template) => ({
+    id: template.id ?? "",
+    name: template.name ?? "",
+    assetCount: Array.isArray(template.assets) ? template.assets.length : 0,
+    updatedAt: template.updatedAt ?? ""
+  }));
+}
+function resolveTemplate(templates, selector) {
+  if (selector.kind === "uuid") {
+    const match = templates.find((template) => template.id === selector.value);
+    if (match) {
+      return match;
+    }
+    throw new CliError(
+      "invalid_cli_usage",
+      `Document template "${selector.value}" was not found.`
+    );
+  }
+  const matches = templates.filter((template) => template.name === selector.value);
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  if (matches.length > 1) {
+    throw new CliError(
+      "invalid_cli_usage",
+      `Document template "${selector.value}" is ambiguous. Found ${matches.length} matches.`
+    );
+  }
+  throw new CliError(
+    "invalid_cli_usage",
+    `Document template "${selector.value}" was not found.`
+  );
+}
+async function resolveTemplateSelector(api, selector) {
+  if (selector.kind === "uuid") {
+    return selector;
+  }
+  const templates = await api.listTemplates();
+  const resolved = resolveTemplate(templates, selector);
+  if (typeof resolved.id !== "string" || resolved.id.length === 0) {
+    throw new CliError(
+      "invalid_cli_usage",
+      `Document template "${selector.value}" is missing an id in the API response.`
+    );
+  }
+  return { kind: "uuid", value: resolved.id };
+}
+function buildCreateInput(options) {
+  const raw = readJsonObjectOption2(options.raw, options.rawFile, "--raw", "--raw-file");
+  const input = { ...raw };
+  if (options.name !== void 0) {
+    input.name = options.name;
+  }
+  if (typeof input.name !== "string" || input.name.trim().length === 0) {
+    throw new CliError("invalid_cli_usage", 'Provide template name via "--name".');
+  }
+  if (input.assets === void 0) {
+    input.assets = [];
+  }
+  return input;
+}
+function buildUpdateInput(options) {
+  const input = {};
+  if (options.name !== void 0) {
+    input.name = options.name;
+  }
+  if (isEmptyObject4(input)) {
+    throw new CliError("invalid_cli_usage", 'Provide template updates via "--name".');
+  }
+  return input;
+}
+function registerDocumentTemplatesCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
   const stdout = getCommandIo5(options.stdout);
-  const files = program.command("files").description("Manage files and storage");
-  files.command("upload").description("Upload a local file").argument("<path>", "path to the local file").action(function action(path) {
-    const { api, json, readOnly } = createFilesApi(this, filePath);
-    ensureWritable4("files upload", readOnly, "write");
-    const contents = readLocalFile(path);
-    const formData = new FormData();
-    formData.append("file", new Blob([contents]), basename(path));
-    return api.uploadFile(formData).then((data) => {
-      if (json) {
-        emitJson5(stdout, "files upload", data, filePath);
-        return;
-      }
-      writeLine5(stdout, `Uploaded file "${basename(path)}".`);
-    });
-  });
-  files.command("download").description("Download a file").argument("<file>", "file identifier").option("--output <path>", "write the downloaded file to a path").action(function action(file, commandOptions) {
+  const templates = program.command("document-templates").description("Manage document templates and their assets");
+  templates.command("list").description("List document templates").action(async function action() {
+    const { api, json } = createDocumentTemplatesApi(this, filePath);
+    const data = await api.listTemplates();
+    if (json) {
+      emitJson5(stdout, "document-templates list", data, filePath);
+      return;
+    }
+    printTable(templateRows(data), ["id", "name", "assetCount", "updatedAt"], stdout);
+  });
+  templates.command("get").description("Get a document template by UUID or exact name").argument("<template>", "template UUID or exact name", parseUuidOrSlugSelector4).action(async function action(template) {
+    const { api, json } = createDocumentTemplatesApi(this, filePath);
+    const list = await api.listTemplates();
+    const data = resolveTemplate(list, template);
+    if (json) {
+      emitJson5(stdout, "document-templates get", data, filePath);
+      return;
+    }
+    printTable([data], void 0, stdout);
+  });
+  templates.command("create").description("Create a document template").option("--name <name>", "template name").option("--raw <json>", "raw create JSON payload").option("--raw-file <path>", "path to raw create JSON payload").action(async function action(commandOptions) {
+    const { api, json, readOnly } = createDocumentTemplatesApi(this, filePath);
+    ensureWritable4("document-templates create", readOnly, "write");
+    const data = await api.createTemplate(buildCreateInput(commandOptions));
+    if (json) {
+      emitJson5(stdout, "document-templates create", data, filePath);
+      return;
+    }
+    writeLine5(stdout, `Created document template "${String(data.name ?? commandOptions.name)}".`);
+  });
+  templates.command("update").description("Rename a document template").argument("<template>", "template UUID or exact name", parseUuidOrSlugSelector4).option("--name <name>", "new template name").action(async function action(template, commandOptions) {
+    const { api, json, readOnly } = createDocumentTemplatesApi(this, filePath);
+    ensureWritable4("document-templates update", readOnly, "write");
+    const resolved = await resolveTemplateSelector(api, template);
+    const data = await api.updateTemplate(resolved, buildUpdateInput(commandOptions));
+    if (json) {
+      emitJson5(stdout, "document-templates update", data, filePath);
+      return;
+    }
+    writeLine5(stdout, `Updated document template "${String(data.name ?? template.value)}".`);
+  });
+  templates.command("delete").description("Delete a document template (and its assets)").argument("<template>", "template UUID or exact name", parseUuidOrSlugSelector4).action(async function action(template) {
+    const { api, json, readOnly } = createDocumentTemplatesApi(this, filePath);
+    ensureWritable4("document-templates delete", readOnly, "destructive");
+    const resolved = await resolveTemplateSelector(api, template);
+    const data = await api.deleteTemplate(resolved);
+    if (json) {
+      emitJson5(stdout, "document-templates delete", data, filePath);
+      return;
+    }
+    writeLine5(stdout, `Deleted document template "${template.value}".`);
+  });
+  const assets = templates.command("assets").description("Manage document template assets");
+  assets.command("add").description("Upload an asset file to a document template").argument("<template>", "template UUID or exact name", parseUuidOrSlugSelector4).argument("<path>", "path to the local file").option("--name <name>", "override the asset display name").action(async function action(template, localPath, commandOptions) {
+    const { api, json, readOnly } = createDocumentTemplatesApi(this, filePath);
+    ensureWritable4("document-templates assets add", readOnly, "write");
+    const contents = readLocalFile(localPath);
+    const formData = new FormData();
+    formData.append("file", new Blob([contents]), basename(localPath));
+    if (commandOptions.name !== void 0) {
+      formData.append("name", commandOptions.name);
+    }
+    const resolved = await resolveTemplateSelector(api, template);
+    const data = await api.addAsset(resolved, formData);
+    if (json) {
+      emitJson5(stdout, "document-templates assets add", data, filePath);
+      return;
+    }
+    writeLine5(
+      stdout,
+      `Added asset "${commandOptions.name ?? basename(localPath)}" to template "${template.value}".`
+    );
+  });
+  assets.command("delete").description("Delete one asset from a document template").argument("<template>", "template UUID or exact name", parseUuidOrSlugSelector4).argument("<asset>", "asset UUID").action(async function action(template, assetId) {
+    const { api, json, readOnly } = createDocumentTemplatesApi(this, filePath);
+    ensureWritable4("document-templates assets delete", readOnly, "destructive");
+    const resolved = await resolveTemplateSelector(api, template);
+    const data = await api.deleteAsset(resolved, assetId);
+    if (json) {
+      emitJson5(stdout, "document-templates assets delete", data, filePath);
+      return;
+    }
+    writeLine5(stdout, `Deleted asset "${assetId}" from template "${template.value}".`);
+  });
+  assets.command("download").description("Download the raw bytes of a document template asset").argument("<template>", "template UUID or exact name", parseUuidOrSlugSelector4).argument("<asset>", "asset UUID").option("--output <path>", "write the downloaded bytes to a path").action(async function action(template, assetId, commandOptions) {
+    const { api, json } = createDocumentTemplatesApi(this, filePath);
+    if (json && !commandOptions.output) {
+      throw new CliError(
+        "invalid_cli_usage",
+        'Provide "--output" when using "--json" with "document-templates assets download".'
+      );
+    }
+    const resolved = await resolveTemplateSelector(api, template);
+    const data = await api.downloadAsset(resolved, assetId);
+    if (commandOptions.output) {
+      writeDownloadedFile(commandOptions.output, data);
+      if (json) {
+        emitJson5(
+          stdout,
+          "document-templates assets download",
+          {
+            template: resolved.value,
+            asset: assetId,
+            output: commandOptions.output,
+            bytes: data.byteLength
+          },
+          filePath
+        );
+        return;
+      }
+      writeLine5(stdout, `Downloaded asset to "${commandOptions.output}".`);
+      return;
+    }
+    writeBinary(stdout, data);
+  });
+}
+
+// src/commands/files.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename2 } from "path";
+import { InvalidArgumentError as InvalidArgumentError5 } from "commander";
+
+// src/api/files.ts
+function selectorValue5(selector) {
+  return selector.value;
+}
+var FilesApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  uploadFile(input) {
+    return this.client.requestJson("/api/v2/files", {
+      method: "POST",
+      body: input
+    });
+  }
+  downloadFile(file) {
+    return this.client.requestBinary(`/api/v2/files/${selectorValue5(file)}`);
+  }
+  deleteFile(file) {
+    return this.client.requestJson(
+      `/api/v2/files/${selectorValue5(file)}`,
+      { method: "DELETE" }
+    );
+  }
+  getStorageInfo() {
+    return this.client.getJson("/api/v2/files/storage-info");
+  }
+};
+
+// src/commands/files.ts
+function getCommandIo6(stdout) {
+  return stdout ?? process.stdout;
+}
+function writeLine6(stdout, value) {
+  stdout.write(`${value}
+`);
+}
+function writeBinary2(stdout, value) {
+  stdout.write(Buffer.from(value));
+}
+function getGlobalOptions6(command) {
+  return command.optsWithGlobals();
+}
+function emitJson6(stdout, commandName, data, configPath, meta = {}) {
+  writeLine6(
+    stdout,
+    JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath, ...meta }))
+  );
+}
+function toConfigurationError6(filePath, error) {
+  if (error instanceof CliError) {
+    throw error;
+  }
+  if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+    throw new CliError("configuration_error", `Config file not found at ${filePath}.`);
+  }
+  if (error instanceof Error) {
+    throw new CliError("configuration_error", error.message);
+  }
+  throw error;
+}
+function createFilesApi(command, filePath) {
+  try {
+    const config = readRuntimeConfig(filePath);
+    const runtime = resolveRuntimeContext(config, getGlobalOptions6(command));
+    if (!runtime.baseUrl) {
+      throw new CliError(
+        "configuration_error",
+        `Resolved profile "${runtime.profile}" is missing a base URL.`
+      );
+    }
+    return {
+      api: new FilesApi(
+        new ApiClient({
+          baseUrl: runtime.baseUrl,
+          apiKey: runtime.apiKey
+        })
+      ),
+      json: runtime.json,
+      readOnly: runtime.readOnly
+    };
+  } catch (error) {
+    toConfigurationError6(filePath, error);
+  }
+}
+function ensureWritable5(commandName, readOnly, commandMode) {
+  if (readOnly) {
+    throw new CliError(
+      "command_not_allowed_in_read_only_mode",
+      `Command "${commandName}" is not allowed in read-only mode.`,
+      {
+        commandMode,
+        executionMode: "read-only"
+      }
+    );
+  }
+}
+function parseUuidOrSlugSelector5(input) {
+  try {
+    return normalizeUuidOrSlug(input);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid selector.";
+    throw new InvalidArgumentError5(message);
+  }
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readLocalFile2(filePath) {
+  try {
+    return readFileSync6(filePath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unable to read file.";
+    throw new CliError("invalid_cli_usage", `Failed to read file at ${filePath}: ${message}`);
+  }
+}
+function writeDownloadedFile2(outputPath, value) {
+  try {
+    writeFileSync3(outputPath, Buffer.from(value));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unable to write file.";
+    throw new CliError(
+      "invalid_cli_usage",
+      `Failed to write downloaded file to ${outputPath}: ${message}`
+    );
+  }
+}
+function registerFilesCommands(program, options = {}) {
+  const filePath = options.configPath ?? defaultConfigPath;
+  const stdout = getCommandIo6(options.stdout);
+  const files = program.command("files").description("Manage files and storage");
+  files.command("upload").description("Upload a local file").argument("<path>", "path to the local file").action(function action(path) {
+    const { api, json, readOnly } = createFilesApi(this, filePath);
+    ensureWritable5("files upload", readOnly, "write");
+    const contents = readLocalFile2(path);
+    const formData = new FormData();
+    formData.append("file", new Blob([contents]), basename2(path));
+    return api.uploadFile(formData).then((data) => {
+      if (json) {
+        emitJson6(stdout, "files upload", data, filePath);
+        return;
+      }
+      writeLine6(stdout, `Uploaded file "${basename2(path)}".`);
+    });
+  });
+  files.command("download").description("Download a file").argument("<file>", "file identifier").option("--output <path>", "write the downloaded file to a path").action(function action(file, commandOptions) {
     const { api, json } = createFilesApi(this, filePath);
     if (json && !commandOptions.output) {
       throw new CliError(
@@ -8906,12 +9530,12 @@ function registerFilesCommands(program, options = {}) {
         'Provide "--output" when using "--json" with "files download".'
       );
     }
-    const fileSelector = parseUuidOrSlugSelector4(file);
+    const fileSelector = parseUuidOrSlugSelector5(file);
     return api.downloadFile(fileSelector).then((data) => {
       if (commandOptions.output) {
-        writeDownloadedFile(commandOptions.output, data);
+        writeDownloadedFile2(commandOptions.output, data);
         if (json) {
-          emitJson5(
+          emitJson6(
             stdout,
             "files download",
             {
@@ -8923,45 +9547,45 @@ function registerFilesCommands(program, options = {}) {
           );
           return;
         }
-        writeLine5(stdout, `Downloaded file to "${commandOptions.output}".`);
+        writeLine6(stdout, `Downloaded file to "${commandOptions.output}".`);
         return;
       }
-      writeBinary(stdout, data);
+      writeBinary2(stdout, data);
     });
   });
   files.command("delete").description("Delete a file").argument("<file>", "file identifier").action(function action(file) {
     const { api, json, readOnly } = createFilesApi(this, filePath);
-    ensureWritable4("files delete", readOnly, "destructive");
-    const fileSelector = parseUuidOrSlugSelector4(file);
+    ensureWritable5("files delete", readOnly, "destructive");
+    const fileSelector = parseUuidOrSlugSelector5(file);
     return api.deleteFile(fileSelector).then((data) => {
       if (json) {
-        emitJson5(stdout, "files delete", data, filePath);
+        emitJson6(stdout, "files delete", data, filePath);
         return;
       }
-      writeLine5(stdout, `Deleted file "${fileSelector.value}".`);
+      writeLine6(stdout, `Deleted file "${fileSelector.value}".`);
     });
   });
   files.command("storage").description("Show storage usage information").action(function action() {
     const { api, json } = createFilesApi(this, filePath);
     return api.getStorageInfo().then((data) => {
       if (json) {
-        emitJson5(stdout, "files storage", data, filePath);
+        emitJson6(stdout, "files storage", data, filePath);
         return;
       }
       if (isRecord3(data)) {
         printTable([data], Object.keys(data), stdout);
         return;
       }
-      writeLine5(stdout, String(data));
+      writeLine6(stdout, String(data));
     });
   });
 }
 
 // src/commands/logs.ts
-import { InvalidArgumentError as InvalidArgumentError5 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError6 } from "commander";
 
 // src/api/logs.ts
-function selectorValue5(selector) {
+function selectorValue6(selector) {
   return selector.value;
 }
 var LogsApi = class {
@@ -8970,29 +9594,29 @@ var LogsApi = class {
   }
   listLogs(schema, recordId) {
     return this.client.getJson(
-      `/api/v2/schemas/${selectorValue5(schema)}/records/${recordId}/logs`
+      `/api/v2/schemas/${selectorValue6(schema)}/records/${recordId}/logs`
     );
   }
 };
 
 // src/commands/logs.ts
-function getCommandIo6(stdout) {
+function getCommandIo7(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine6(stdout, value) {
+function writeLine7(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions6(command) {
+function getGlobalOptions7(command) {
   return command.optsWithGlobals();
 }
-function emitJson6(stdout, commandName, data, ..._extra) {
-  writeLine6(
+function emitJson7(stdout, commandName, data, ..._extra) {
+  writeLine7(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName }))
   );
 }
-function toConfigurationError6(filePath, error) {
+function toConfigurationError7(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -9007,7 +9631,7 @@ function toConfigurationError6(filePath, error) {
 function createLogsApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions6(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions7(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -9024,25 +9648,25 @@ function createLogsApi(command, filePath) {
       json: runtime.json
     };
   } catch (error) {
-    toConfigurationError6(filePath, error);
+    toConfigurationError7(filePath, error);
   }
 }
-function parseUuidOrSlugSelector5(input) {
+function parseUuidOrSlugSelector6(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError5(message);
+    throw new InvalidArgumentError6(message);
   }
 }
-function isJsonObject4(value) {
+function isJsonObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toTableRows3(data) {
   if (Array.isArray(data)) {
-    return data.map((entry) => isJsonObject4(entry) ? entry : { value: entry });
+    return data.map((entry) => isJsonObject5(entry) ? entry : { value: entry });
   }
-  if (isJsonObject4(data)) {
+  if (isJsonObject5(data)) {
     return [data];
   }
   return [{ value: data }];
@@ -9052,13 +9676,13 @@ function emitTable3(stdout, data) {
 }
 function registerLogsCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo6(options.stdout);
+  const stdout = getCommandIo7(options.stdout);
   const logs = program.command("logs").description("Inspect record change logs");
-  logs.command("list").description("List change logs for a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector5).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector5).action(async function action(schema, record) {
+  logs.command("list").description("List change logs for a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector6).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector6).action(async function action(schema, record) {
     const { api, json } = createLogsApi(this, filePath);
     const data = await api.listLogs(schema, record.value);
     if (json) {
-      emitJson6(stdout, "logs list", data, filePath);
+      emitJson7(stdout, "logs list", data, filePath);
       return;
     }
     emitTable3(stdout, data);
@@ -9066,11 +9690,11 @@ function registerLogsCommands(program, options = {}) {
 }
 
 // src/commands/navigation.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError6 } from "commander";
+import { readFileSync as readFileSync7 } from "fs";
+import { InvalidArgumentError as InvalidArgumentError7 } from "commander";
 
 // src/api/navigation.ts
-function jsonOptions4(body, method) {
+function jsonOptions5(body, method) {
   return {
     method,
     headers: {
@@ -9079,7 +9703,7 @@ function jsonOptions4(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue6(selector) {
+function selectorValue7(selector) {
   return selector.value;
 }
 var NavigationApi = class {
@@ -9092,44 +9716,44 @@ var NavigationApi = class {
   createFolder(body) {
     return this.client.requestJson(
       "/api/v2/navigation/folders",
-      jsonOptions4(body, "POST")
+      jsonOptions5(body, "POST")
     );
   }
   updateFolder(folder, body) {
     return this.client.requestJson(
-      `/api/v2/navigation/folders/${selectorValue6(folder)}`,
-      jsonOptions4(body, "PATCH")
+      `/api/v2/navigation/folders/${selectorValue7(folder)}`,
+      jsonOptions5(body, "PATCH")
     );
   }
   deleteFolder(folder) {
     return this.client.requestJson(
-      `/api/v2/navigation/folders/${selectorValue6(folder)}`,
+      `/api/v2/navigation/folders/${selectorValue7(folder)}`,
       { method: "DELETE" }
     );
   }
   moveResource(body) {
     return this.client.requestJson(
       "/api/v2/navigation/resources:move",
-      jsonOptions4(body, "POST")
+      jsonOptions5(body, "POST")
     );
   }
 };
 
 // src/commands/navigation.ts
-function getCommandIo7(stdout) {
+function getCommandIo8(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine7(stdout, value) {
+function writeLine8(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions7(command) {
+function getGlobalOptions8(command) {
   return command.optsWithGlobals();
 }
-function emitJson7(stdout, commandName, data, configPath) {
-  writeLine7(stdout, JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath })));
+function emitJson8(stdout, commandName, data, configPath) {
+  writeLine8(stdout, JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath })));
 }
-function toConfigurationError7(filePath, error) {
+function toConfigurationError8(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -9144,7 +9768,7 @@ function toConfigurationError7(filePath, error) {
 function createNavigationApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions7(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions8(command));
     if (!runtime.baseUrl) {
       throw new CliError("configuration_error", `Resolved profile "${runtime.profile}" is missing a base URL.`);
     }
@@ -9159,10 +9783,10 @@ function createNavigationApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError7(filePath, error);
+    toConfigurationError8(filePath, error);
   }
 }
-function ensureWritable5(commandName, readOnly, mode) {
+function ensureWritable6(commandName, readOnly, mode) {
   if (readOnly) {
     throw new CliError(
       "command_not_allowed_in_read_only_mode",
@@ -9171,12 +9795,12 @@ function ensureWritable5(commandName, readOnly, mode) {
     );
   }
 }
-function parseUuidOrSlugSelector6(input) {
+function parseUuidOrSlugSelector7(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError6(message);
+    throw new InvalidArgumentError7(message);
   }
 }
 function parseInteger(value, flagName) {
@@ -9193,7 +9817,7 @@ function readJsonObject(raw, rawFile) {
   if (raw && rawFile) {
     throw new CliError("invalid_cli_usage", 'Use either "--props" or "--props-file", not both.');
   }
-  const source = rawFile ? readFileSync6(rawFile, "utf8") : raw;
+  const source = rawFile ? readFileSync7(rawFile, "utf8") : raw;
   if (!source) {
     return {};
   }
@@ -9255,41 +9879,41 @@ function folderRows2(folders) {
 }
 function registerNavigationCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo7(options.stdout);
+  const stdout = getCommandIo8(options.stdout);
   const navigation = program.command("navigation").description("Manage workspace navigation");
   const folders = navigation.command("folders").description("Manage navigation folders");
   folders.command("list").description("List navigation folders").action(async function action() {
     const { api, json } = createNavigationApi(this, filePath);
     const data = await api.listFolders();
     if (json) {
-      emitJson7(stdout, "navigation folders list", data, filePath);
+      emitJson8(stdout, "navigation folders list", data, filePath);
       return;
     }
     printTable(folderRows2(data), ["id", "order", "name", "resourceCount"], stdout);
   });
-  folders.command("get").description("Get a navigation folder by UUID or exact name").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector6).action(async function action(folder) {
+  folders.command("get").description("Get a navigation folder by UUID or exact name").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector7).action(async function action(folder) {
     const { api, json } = createNavigationApi(this, filePath);
     const data = await api.listFolders();
     const resolved = resolveFolder2(data, folder);
     if (json) {
-      emitJson7(stdout, "navigation folders get", resolved, filePath);
+      emitJson8(stdout, "navigation folders get", resolved, filePath);
       return;
     }
     printTable(folderRows2([resolved]), ["id", "order", "name", "resourceCount"], stdout);
   });
   folders.command("create").description("Create a navigation folder").requiredOption("--name <name>", "folder name").option("--order <n>", "folder order").option("--props <json>", "folder additionalProperties JSON").option("--props-file <path>", "folder additionalProperties JSON file").action(async function action(commandOptions) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
-    ensureWritable5("navigation folders create", readOnly, "write");
+    ensureWritable6("navigation folders create", readOnly, "write");
     const data = await api.createFolder(buildFolderBody(commandOptions));
     if (json) {
-      emitJson7(stdout, "navigation folders create", data, filePath);
+      emitJson8(stdout, "navigation folders create", data, filePath);
       return;
     }
-    writeLine7(stdout, `Created navigation folder "${String(data.name ?? commandOptions.name)}".`);
+    writeLine8(stdout, `Created navigation folder "${String(data.name ?? commandOptions.name)}".`);
   });
-  folders.command("update").description("Update a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector6).option("--name <name>", "folder name").option("--order <n>", "folder order").option("--props <json>", "folder additionalProperties JSON").option("--props-file <path>", "folder additionalProperties JSON file").action(async function action(folder, commandOptions) {
+  folders.command("update").description("Update a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector7).option("--name <name>", "folder name").option("--order <n>", "folder order").option("--props <json>", "folder additionalProperties JSON").option("--props-file <path>", "folder additionalProperties JSON file").action(async function action(folder, commandOptions) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
-    ensureWritable5("navigation folders update", readOnly, "write");
+    ensureWritable6("navigation folders update", readOnly, "write");
     const allFolders = await api.listFolders();
     const resolved = resolveFolder2(allFolders, folder);
     const body = buildFolderBody(commandOptions);
@@ -9298,54 +9922,54 @@ function registerNavigationCommands(program, options = {}) {
     }
     const data = await api.updateFolder({ kind: "uuid", value: resolved.id }, body);
     if (json) {
-      emitJson7(stdout, "navigation folders update", data, filePath);
+      emitJson8(stdout, "navigation folders update", data, filePath);
       return;
     }
-    writeLine7(stdout, `Updated navigation folder "${String(data.name ?? resolved.name ?? resolved.id)}".`);
+    writeLine8(stdout, `Updated navigation folder "${String(data.name ?? resolved.name ?? resolved.id)}".`);
   });
-  folders.command("delete").description("Delete a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector6).action(async function action(folder) {
+  folders.command("delete").description("Delete a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector7).action(async function action(folder) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
-    ensureWritable5("navigation folders delete", readOnly, "destructive");
+    ensureWritable6("navigation folders delete", readOnly, "destructive");
     const allFolders = await api.listFolders();
     const resolved = resolveFolder2(allFolders, folder);
     const data = await api.deleteFolder({ kind: "uuid", value: resolved.id });
     if (json) {
-      emitJson7(stdout, "navigation folders delete", data, filePath);
+      emitJson8(stdout, "navigation folders delete", data, filePath);
       return;
     }
-    writeLine7(stdout, `Deleted navigation folder "${resolved.name ?? resolved.id}".`);
+    writeLine8(stdout, `Deleted navigation folder "${resolved.name ?? resolved.id}".`);
   });
   navigation.command("resources").description("Manage navigation resources").command("move").description("Move a resource into a folder").argument("<resource>", "resource UUID").requiredOption("--type <type>", "resource type").requiredOption("--to <folder>", "target folder UUID or exact name").action(async function action(resourceId, commandOptions) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
-    ensureWritable5("navigation resources move", readOnly, "write");
+    ensureWritable6("navigation resources move", readOnly, "write");
     const allFolders = await api.listFolders();
-    const resolved = resolveFolder2(allFolders, parseUuidOrSlugSelector6(commandOptions.to));
+    const resolved = resolveFolder2(allFolders, parseUuidOrSlugSelector7(commandOptions.to));
     const data = await api.moveResource({
       resourceId,
       resourceType: commandOptions.type.toUpperCase(),
       targetFolderId: resolved.id
     });
     if (json) {
-      emitJson7(stdout, "navigation resources move", data, filePath);
+      emitJson8(stdout, "navigation resources move", data, filePath);
       return;
     }
-    writeLine7(stdout, `Moved resource "${resourceId}" to "${resolved.name ?? resolved.id}".`);
+    writeLine8(stdout, `Moved resource "${resourceId}" to "${resolved.name ?? resolved.id}".`);
   });
 }
 
 // src/commands/profiles.ts
-function getCommandIo8(stdout) {
+function getCommandIo9(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine8(stdout, value) {
+function writeLine9(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions8(command) {
+function getGlobalOptions9(command) {
   return command.optsWithGlobals();
 }
-function emitJson8(stdout, commandName, data, configPath) {
-  writeLine8(
+function emitJson9(stdout, commandName, data, configPath) {
+  writeLine9(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath }))
   );
@@ -9401,15 +10025,15 @@ function emitProfilesTable(stdout, data) {
 }
 function registerProfilesCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo8(options.stdout);
+  const stdout = getCommandIo9(options.stdout);
   const profiles = program.command("profiles").description("Manage local CLI profiles");
   profiles.command("list").description("List configured profiles").action(function action() {
     const config = readRequiredConfig(filePath);
     const data = Object.entries(config.profiles).map(
       ([name, profile]) => toDisplayProfile(name, profile, config.defaultProfile)
     );
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles list", data, filePath);
+    if (getGlobalOptions9(this).json) {
+      emitJson9(stdout, "profiles list", data, filePath);
       return;
     }
     emitProfilesTable(stdout, data);
@@ -9418,8 +10042,8 @@ function registerProfilesCommands(program, options = {}) {
     const config = readRequiredConfig(filePath);
     const profile = getRequiredProfile(config, profileName);
     const data = toDisplayProfile(profileName, profile, config.defaultProfile);
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles get", data, filePath);
+    if (getGlobalOptions9(this).json) {
+      emitJson9(stdout, "profiles get", data, filePath);
       return;
     }
     emitProfilesTable(stdout, [data]);
@@ -9433,11 +10057,11 @@ function registerProfilesCommands(program, options = {}) {
       profile: profileName,
       defaultProfile: nextConfig.defaultProfile
     };
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles use", data, filePath);
+    if (getGlobalOptions9(this).json) {
+      emitJson9(stdout, "profiles use", data, filePath);
       return;
     }
-    writeLine8(stdout, `Using profile "${profileName}".`);
+    writeLine9(stdout, `Using profile "${profileName}".`);
   });
   profiles.command("add").description("Add a profile to the local config").argument("<profile>", "profile name").requiredOption("--api-key <token>", "API key").option("--base-url <url>", "base URL").action(function action(profileName, commandOptions) {
     const config = loadConfigForAdd(filePath);
@@ -9461,11 +10085,11 @@ function registerProfilesCommands(program, options = {}) {
       nextConfig.profiles[profileName] ?? {},
       nextConfig.defaultProfile
     );
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles add", data, filePath);
+    if (getGlobalOptions9(this).json) {
+      emitJson9(stdout, "profiles add", data, filePath);
       return;
     }
-    writeLine8(stdout, `Added profile "${profileName}".`);
+    writeLine9(stdout, `Added profile "${profileName}".`);
   });
   profiles.command("update").description("Update an existing profile").argument("<profile>", "profile name").option("--api-key <token>", "API key").option("--base-url <url>", "base URL").action(function action(profileName, commandOptions) {
     if (commandOptions.apiKey === void 0 && commandOptions.baseUrl === void 0) {
@@ -9487,11 +10111,11 @@ function registerProfilesCommands(program, options = {}) {
       nextConfig.profiles[profileName] ?? {},
       nextConfig.defaultProfile
     );
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles update", data, filePath);
+    if (getGlobalOptions9(this).json) {
+      emitJson9(stdout, "profiles update", data, filePath);
       return;
     }
-    writeLine8(stdout, `Updated profile "${profileName}".`);
+    writeLine9(stdout, `Updated profile "${profileName}".`);
   });
   profiles.command("remove").description("Remove a profile from the local config").argument("<profile>", "profile name").action(function action(profileName) {
     const config = readRequiredConfig(filePath);
@@ -9502,20 +10126,20 @@ function registerProfilesCommands(program, options = {}) {
       profile: profileName,
       defaultProfile: nextConfig.defaultProfile
     };
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles remove", data, filePath);
+    if (getGlobalOptions9(this).json) {
+      emitJson9(stdout, "profiles remove", data, filePath);
       return;
     }
-    writeLine8(stdout, `Removed profile "${profileName}".`);
+    writeLine9(stdout, `Removed profile "${profileName}".`);
   });
 }
 
 // src/commands/records.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError7 } from "commander";
+import { readFileSync as readFileSync8 } from "fs";
+import { InvalidArgumentError as InvalidArgumentError8 } from "commander";
 
 // src/api/records.ts
-function jsonOptions5(body, method) {
+function jsonOptions6(body, method) {
   return {
     method,
     headers: {
@@ -9524,7 +10148,7 @@ function jsonOptions5(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue7(selector) {
+function selectorValue8(selector) {
   return selector.value;
 }
 var RecordsApi = class {
@@ -9539,7 +10163,7 @@ var RecordsApi = class {
     if (query.offset !== void 0) {
       params.set("offset", String(query.offset));
     }
-    const path = `/api/v2/schemas/${selectorValue7(schema)}/records`;
+    const path = `/api/v2/schemas/${selectorValue8(schema)}/records`;
     const queryString = params.toString();
     return this.client.getJson(
       queryString ? `${path}?${queryString}` : path
@@ -9548,36 +10172,36 @@ var RecordsApi = class {
   queryRecords(schema, query) {
     const body = this.normalizeQueryInput(query);
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue7(schema)}/records:query`,
-      jsonOptions5(body, "POST")
+      `/api/v2/schemas/${selectorValue8(schema)}/records:query`,
+      jsonOptions6(body, "POST")
     );
   }
   getRecord(schema, record) {
     return this.client.getJson(
-      `/api/v2/schemas/${selectorValue7(schema)}/records/${selectorValue7(record)}`
+      `/api/v2/schemas/${selectorValue8(schema)}/records/${selectorValue8(record)}`
     );
   }
   createRecord(schema, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue7(schema)}/records`,
-      jsonOptions5(input, "POST")
+      `/api/v2/schemas/${selectorValue8(schema)}/records`,
+      jsonOptions6(input, "POST")
     );
   }
   updateRecord(schema, record, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue7(schema)}/records/${selectorValue7(record)}`,
-      jsonOptions5(input, "PATCH")
+      `/api/v2/schemas/${selectorValue8(schema)}/records/${selectorValue8(record)}`,
+      jsonOptions6(input, "PATCH")
     );
   }
   deleteRecord(schema, record) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue7(schema)}/records/${selectorValue7(record)}`,
+      `/api/v2/schemas/${selectorValue8(schema)}/records/${selectorValue8(record)}`,
       { method: "DELETE" }
     );
   }
   clearRecords(schema) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue7(schema)}/records:clear`,
+      `/api/v2/schemas/${selectorValue8(schema)}/records:clear`,
       { method: "DELETE" }
     );
   }
@@ -9610,7 +10234,7 @@ var RecordsApi = class {
 };
 
 // src/api/schemas.ts
-function jsonOptions6(body, method) {
+function jsonOptions7(body, method) {
   return {
     method,
     headers: {
@@ -9619,7 +10243,7 @@ function jsonOptions6(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue8(selector) {
+function selectorValue9(selector) {
   return selector.value;
 }
 var SchemasApi = class {
@@ -9630,20 +10254,20 @@ var SchemasApi = class {
     return this.client.getJson("/api/v2/schemas");
   }
   getSchema(schema) {
-    return this.client.getJson(`/api/v2/schemas/${selectorValue8(schema)}`);
+    return this.client.getJson(`/api/v2/schemas/${selectorValue9(schema)}`);
   }
   createSchema(input) {
-    return this.client.requestJson("/api/v2/schemas", jsonOptions6(input, "POST"));
+    return this.client.requestJson("/api/v2/schemas", jsonOptions7(input, "POST"));
   }
   updateSchema(schema, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}`,
-      jsonOptions6(input, "PATCH")
+      `/api/v2/schemas/${selectorValue9(schema)}`,
+      jsonOptions7(input, "PATCH")
     );
   }
   deleteSchema(schema) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}`,
+      `/api/v2/schemas/${selectorValue9(schema)}`,
       { method: "DELETE" }
     );
   }
@@ -9653,47 +10277,47 @@ var SchemasApi = class {
   }
   getField(schema, field) {
     return this.client.getJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/fields/${selectorValue8(field)}`
+      `/api/v2/schemas/${selectorValue9(schema)}/fields/${selectorValue9(field)}`
     );
   }
   createField(schema, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/fields`,
-      jsonOptions6(input, "POST")
+      `/api/v2/schemas/${selectorValue9(schema)}/fields`,
+      jsonOptions7(input, "POST")
     );
   }
   updateField(schema, field, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/fields/${selectorValue8(field)}`,
-      jsonOptions6(input, "PATCH")
+      `/api/v2/schemas/${selectorValue9(schema)}/fields/${selectorValue9(field)}`,
+      jsonOptions7(input, "PATCH")
     );
   }
   deleteField(schema, field) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/fields/${selectorValue8(field)}`,
+      `/api/v2/schemas/${selectorValue9(schema)}/fields/${selectorValue9(field)}`,
       { method: "DELETE" }
     );
   }
 };
 
 // src/commands/records.ts
-function getCommandIo9(stdout) {
+function getCommandIo10(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine9(stdout, value) {
+function writeLine10(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions9(command) {
+function getGlobalOptions10(command) {
   return command.optsWithGlobals();
 }
-function emitJson9(stdout, commandName, data, configPath, meta = {}) {
-  writeLine9(
+function emitJson10(stdout, commandName, data, configPath, meta = {}) {
+  writeLine10(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath, ...meta }))
   );
 }
-function toConfigurationError8(filePath, error) {
+function toConfigurationError9(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -9708,7 +10332,7 @@ function toConfigurationError8(filePath, error) {
 function createRecordsApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions9(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions10(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -9727,10 +10351,10 @@ function createRecordsApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError8(filePath, error);
+    toConfigurationError9(filePath, error);
   }
 }
-function ensureWritable6(commandName, readOnly, commandMode) {
+function ensureWritable7(commandName, readOnly, commandMode) {
   if (readOnly) {
     throw new CliError(
       "command_not_allowed_in_read_only_mode",
@@ -9742,24 +10366,24 @@ function ensureWritable6(commandName, readOnly, commandMode) {
     );
   }
 }
-function parseUuidOrSlugSelector7(input) {
+function parseUuidOrSlugSelector8(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError7(message);
+    throw new InvalidArgumentError8(message);
   }
 }
 function parseNonNegativeInteger2(input) {
   if (!/^\d+$/.test(input.trim())) {
-    throw new InvalidArgumentError7(`Expected a non-negative integer, received "${input}".`);
+    throw new InvalidArgumentError8(`Expected a non-negative integer, received "${input}".`);
   }
   return Number(input);
 }
 function parseCommaSeparatedValues(input, label) {
   const values = input.split(",").map((value) => value.trim()).filter(Boolean);
   if (values.length === 0) {
-    throw new InvalidArgumentError7(`Expected ${label} to contain at least one value.`);
+    throw new InvalidArgumentError8(`Expected ${label} to contain at least one value.`);
   }
   return values;
 }
@@ -9768,7 +10392,7 @@ function parseExpressionValue(input) {
     return parseExpression(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid expression.";
-    throw new InvalidArgumentError7(message);
+    throw new InvalidArgumentError8(message);
   }
 }
 function parseKeyValueAssignment(input) {
@@ -9776,7 +10400,7 @@ function parseKeyValueAssignment(input) {
     return parseKeyValue(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid assignment.";
-    throw new InvalidArgumentError7(message);
+    throw new InvalidArgumentError8(message);
   }
 }
 function parseJsonKeyValueAssignment(input) {
@@ -9784,7 +10408,7 @@ function parseJsonKeyValueAssignment(input) {
     return parseJsonAssignment(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid JSON assignment.";
-    throw new InvalidArgumentError7(message);
+    throw new InvalidArgumentError8(message);
   }
 }
 function collectStringValues(value, previous = []) {
@@ -9802,7 +10426,7 @@ function collectKeyValueAssignments(value, previous = []) {
 function collectJsonAssignments(value, previous = []) {
   return [...previous, parseJsonKeyValueAssignment(value)];
 }
-function isJsonObject5(value) {
+function isJsonObject6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseRawJsonObject2(input, sourceLabel) {
@@ -9816,7 +10440,7 @@ function parseRawJsonObject2(input, sourceLabel) {
       `Failed to parse JSON from ${sourceLabel}: ${message}`
     );
   }
-  if (!isJsonObject5(parsed)) {
+  if (!isJsonObject6(parsed)) {
     throw new CliError(
       "invalid_cli_usage",
       `Expected ${sourceLabel} to contain a JSON object.`
@@ -9837,7 +10461,7 @@ function readRawObject3(raw, rawFile) {
   if (rawFile) {
     let contents;
     try {
-      contents = readFileSync7(rawFile, "utf8");
+      contents = readFileSync8(rawFile, "utf8");
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unable to read file.";
       throw new CliError(
@@ -9849,7 +10473,7 @@ function readRawObject3(raw, rawFile) {
   }
   return {};
 }
-function isEmptyObject4(value) {
+function isEmptyObject5(value) {
   return Object.keys(value).length === 0;
 }
 function buildAssignmentObject(assignments = [], jsonAssignments = []) {
@@ -9897,7 +10521,7 @@ function buildRecordCreateInput(options) {
     ...readRawObject3(options.raw, options.rawFile),
     ...buildAssignmentObject(options.set, options.setJson)
   };
-  if (isEmptyObject4(values)) {
+  if (isEmptyObject5(values)) {
     throw new CliError(
       "invalid_cli_usage",
       'Provide record fields via "--set", "--set-json", "--raw", or "--raw-file".'
@@ -9910,7 +10534,7 @@ function readRawSetPayload2(raw) {
   if (setValue === void 0) {
     return {};
   }
-  if (!isJsonObject5(setValue)) {
+  if (!isJsonObject6(setValue)) {
     throw new CliError(
       "invalid_cli_usage",
       'Expected raw update payload field "set" to be a JSON object.'
@@ -9955,7 +10579,7 @@ function buildRecordUpdateInput(options) {
   } else {
     delete input.unset;
   }
-  if (isEmptyObject4(input)) {
+  if (isEmptyObject5(input)) {
     throw new CliError(
       "invalid_cli_usage",
       'Provide record updates via "--set", "--set-json", "--unset", "--raw", or "--raw-file".'
@@ -9965,9 +10589,9 @@ function buildRecordUpdateInput(options) {
 }
 function toTableRows4(data) {
   if (Array.isArray(data)) {
-    return data.map((entry) => isJsonObject5(entry) ? entry : { value: entry });
+    return data.map((entry) => isJsonObject6(entry) ? entry : { value: entry });
   }
-  if (isJsonObject5(data)) {
+  if (isJsonObject6(data)) {
     return [data];
   }
   return [{ value: data }];
@@ -9997,9 +10621,9 @@ async function resolveSchemaSelector(api, selector) {
 }
 function registerRecordsCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo9(options.stdout);
+  const stdout = getCommandIo10(options.stdout);
   const records = program.command("records").description("Manage schema records");
-  records.command("list").description("List records for a schema with simple pagination").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).option("--limit <number>", "limit results", parseNonNegativeInteger2).option("--offset <number>", "offset results", parseNonNegativeInteger2).action(async function action(schema, commandOptions) {
+  records.command("list").description("List records for a schema with simple pagination").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--limit <number>", "limit results", parseNonNegativeInteger2).option("--offset <number>", "offset results", parseNonNegativeInteger2).action(async function action(schema, commandOptions) {
     const { api, schemasApi, json } = createRecordsApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.listRecords(
@@ -10008,7 +10632,7 @@ function registerRecordsCommands(program, options = {}) {
     );
     const recordsData = getQueryRecords(data);
     if (json) {
-      emitJson9(
+      emitJson10(
         stdout,
         "records list",
         recordsData,
@@ -10019,7 +10643,7 @@ function registerRecordsCommands(program, options = {}) {
     }
     emitTable4(stdout, recordsData);
   });
-  records.command("query").description("Query records for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).option("--select <fields>", "comma-separated field selection", (value) => parseCommaSeparatedValues(value, "--select")).option("--where <expression>", "where expression", collectWhereExpressions, []).option("--sort <field:direction>", "sort field(s)", collectSortValues, []).option("--limit <number>", "limit results", parseNonNegativeInteger2).option("--offset <number>", "offset results", parseNonNegativeInteger2).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
+  records.command("query").description("Query records for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--select <fields>", "comma-separated field selection", (value) => parseCommaSeparatedValues(value, "--select")).option("--where <expression>", "where expression", collectWhereExpressions, []).option("--sort <field:direction>", "sort field(s)", collectSortValues, []).option("--limit <number>", "limit results", parseNonNegativeInteger2).option("--offset <number>", "offset results", parseNonNegativeInteger2).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
     const { api, schemasApi, json } = createRecordsApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.queryRecords(
@@ -10028,7 +10652,7 @@ function registerRecordsCommands(program, options = {}) {
     );
     const recordsData = getQueryRecords(data);
     if (json) {
-      emitJson9(
+      emitJson10(
         stdout,
         "records query",
         recordsData,
@@ -10039,33 +10663,33 @@ function registerRecordsCommands(program, options = {}) {
     }
     emitTable4(stdout, recordsData);
   });
-  records.command("get").description("Get a record by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector7).action(async function action(schema, record) {
+  records.command("get").description("Get a record by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema, record) {
     const { api, schemasApi, json } = createRecordsApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.getRecord(resolvedSchema, record);
     if (json) {
-      emitJson9(stdout, "records get", data, filePath);
+      emitJson10(stdout, "records get", data, filePath);
       return;
     }
     emitTable4(stdout, data);
   });
-  records.command("create").description("Create a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
+  records.command("create").description("Create a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
-    ensureWritable6("records create", readOnly, "write");
+    ensureWritable7("records create", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.createRecord(
       resolvedSchema,
       buildRecordCreateInput(commandOptions)
     );
     if (json) {
-      emitJson9(stdout, "records create", data, filePath);
+      emitJson10(stdout, "records create", data, filePath);
       return;
     }
-    writeLine9(stdout, `Created record "${getRecordIdentifier(data)}".`);
+    writeLine10(stdout, `Created record "${getRecordIdentifier(data)}".`);
   });
-  records.command("update").description("Update a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector7).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--unset <field>", "unset a field", collectStringValues, []).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, record, commandOptions) {
+  records.command("update").description("Update a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector8).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--unset <field>", "unset a field", collectStringValues, []).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, record, commandOptions) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
-    ensureWritable6("records update", readOnly, "write");
+    ensureWritable7("records update", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.updateRecord(
       resolvedSchema,
@@ -10073,14 +10697,14 @@ function registerRecordsCommands(program, options = {}) {
       buildRecordUpdateInput(commandOptions)
     );
     if (json) {
-      emitJson9(stdout, "records update", data, filePath);
+      emitJson10(stdout, "records update", data, filePath);
       return;
     }
-    writeLine9(stdout, `Updated record "${getRecordIdentifier(data)}".`);
+    writeLine10(stdout, `Updated record "${getRecordIdentifier(data)}".`);
   });
-  records.command("delete").description("Delete a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector7).action(async function action(schema, record) {
+  records.command("delete").description("Delete a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema, record) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
-    ensureWritable6("records delete", readOnly, "destructive");
+    ensureWritable7("records delete", readOnly, "destructive");
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     await api.deleteRecord(resolvedSchema, record);
     const data = {
@@ -10089,44 +10713,44 @@ function registerRecordsCommands(program, options = {}) {
       deleted: true
     };
     if (json) {
-      emitJson9(stdout, "records delete", data, filePath);
+      emitJson10(stdout, "records delete", data, filePath);
       return;
     }
-    writeLine9(stdout, `Deleted record "${record.value}" from schema "${schema.value}".`);
+    writeLine10(stdout, `Deleted record "${record.value}" from schema "${schema.value}".`);
   });
-  records.command("clear").description("Delete all records from a schema's table").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).action(async function action(schema) {
+  records.command("clear").description("Delete all records from a schema's table").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
-    ensureWritable6("records clear", readOnly, "destructive");
+    ensureWritable7("records clear", readOnly, "destructive");
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.clearRecords(resolvedSchema);
     if (json) {
-      emitJson9(stdout, "records clear", data, filePath);
+      emitJson10(stdout, "records clear", data, filePath);
       return;
     }
-    writeLine9(stdout, `Cleared all records from schema "${schema.value}".`);
+    writeLine10(stdout, `Cleared all records from schema "${schema.value}".`);
   });
 }
 
 // src/commands/schemas.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError8 } from "commander";
-function getCommandIo10(stdout) {
+import { readFileSync as readFileSync9 } from "fs";
+import { InvalidArgumentError as InvalidArgumentError9 } from "commander";
+function getCommandIo11(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine10(stdout, value) {
+function writeLine11(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions10(command) {
+function getGlobalOptions11(command) {
   return command.optsWithGlobals();
 }
-function emitJson10(stdout, commandName, data, configPath) {
-  writeLine10(
+function emitJson11(stdout, commandName, data, configPath) {
+  writeLine11(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath }))
   );
 }
-function toConfigurationError9(filePath, error) {
+function toConfigurationError10(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -10141,7 +10765,7 @@ function toConfigurationError9(filePath, error) {
 function createSchemasApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions10(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions11(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -10160,10 +10784,10 @@ function createSchemasApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError9(filePath, error);
+    toConfigurationError10(filePath, error);
   }
 }
-function ensureWritable7(commandName, readOnly, commandMode) {
+function ensureWritable8(commandName, readOnly, commandMode) {
   if (readOnly) {
     throw new CliError(
       "command_not_allowed_in_read_only_mode",
@@ -10175,12 +10799,12 @@ function ensureWritable7(commandName, readOnly, commandMode) {
     );
   }
 }
-function parseUuidOrSlugSelector8(input) {
+function parseUuidOrSlugSelector9(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError8(message);
+    throw new InvalidArgumentError9(message);
   }
 }
 function parseBooleanFlag(input) {
@@ -10191,9 +10815,9 @@ function parseBooleanFlag(input) {
   if (["false", "0", "no", "n", "off"].includes(normalized)) {
     return false;
   }
-  throw new InvalidArgumentError8(`Expected a boolean value, received "${input}".`);
+  throw new InvalidArgumentError9(`Expected a boolean value, received "${input}".`);
 }
-function isJsonObject6(value) {
+function isJsonObject7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseRawJsonObject3(input, sourceLabel) {
@@ -10207,7 +10831,7 @@ function parseRawJsonObject3(input, sourceLabel) {
       `Failed to parse JSON from ${sourceLabel}: ${message}`
     );
   }
-  if (!isJsonObject6(parsed)) {
+  if (!isJsonObject7(parsed)) {
     throw new CliError(
       "invalid_cli_usage",
       `Expected ${sourceLabel} to contain a JSON object.`
@@ -10228,7 +10852,7 @@ function readRawObject4(raw, rawFile) {
   if (rawFile) {
     let contents;
     try {
-      contents = readFileSync8(rawFile, "utf8");
+      contents = readFileSync9(rawFile, "utf8");
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unable to read file.";
       throw new CliError(
@@ -10287,7 +10911,7 @@ function applyFieldDefaultValue(input, defaultValue) {
     return;
   }
   const config = input.config;
-  if (config !== void 0 && !isJsonObject6(config)) {
+  if (config !== void 0 && !isJsonObject7(config)) {
     throw new CliError(
       "invalid_cli_usage",
       'Expected field "config" to be a JSON object when using "--default".'
@@ -10327,7 +10951,7 @@ function buildFieldCreateInput(options) {
     input.required = options.required;
   }
   applyFieldDefaultValue(input, options.default);
-  if ("config" in input && isJsonObject6(input.config) && isEmptyObject5(input.config)) {
+  if ("config" in input && isJsonObject7(input.config) && isEmptyObject6(input.config)) {
     delete input.config;
   }
   return input;
@@ -10400,35 +11024,35 @@ async function resolveFieldSelector(api, schema, selector) {
     value: match.id
   };
 }
-function isEmptyObject5(value) {
+function isEmptyObject6(value) {
   return Object.keys(value).length === 0;
 }
 function registerSchemasCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo10(options.stdout);
+  const stdout = getCommandIo11(options.stdout);
   const schemas = program.command("schemas").description("Manage schemas and schema fields");
   schemas.command("list").description("List schemas").action(async function action() {
     const { api, json } = createSchemasApi(this, filePath);
     const data = await api.listSchemas();
     if (json) {
-      emitJson10(stdout, "schemas list", data, filePath);
+      emitJson11(stdout, "schemas list", data, filePath);
       return;
     }
     emitSchemasTable(stdout, data);
   });
-  schemas.command("get").description("Get a schema by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema) {
+  schemas.command("get").description("Get a schema by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema) {
     const { api, json } = createSchemasApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const data = await api.getSchema(resolvedSchema);
     if (json) {
-      emitJson10(stdout, "schemas get", data, filePath);
+      emitJson11(stdout, "schemas get", data, filePath);
       return;
     }
     emitSchemasTable(stdout, [data]);
   });
   schemas.command("create").description("Create a schema").requiredOption("--name <name>", "schema name").requiredOption("--slug <slug>", "schema slug").option("--auditable", "mark schema as auditable").option("--commentable", "mark schema as commentable").action(async function action(commandOptions) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable7("schemas create", readOnly, "write");
+    ensureWritable8("schemas create", readOnly, "write");
     const input = {
       name: commandOptions.name,
       slug: commandOptions.slug,
@@ -10437,17 +11061,17 @@ function registerSchemasCommands(program, options = {}) {
     };
     const data = await api.createSchema(input);
     if (json) {
-      emitJson10(stdout, "schemas create", data, filePath);
+      emitJson11(stdout, "schemas create", data, filePath);
       return;
     }
-    writeLine10(stdout, `Created schema "${data.slug ?? commandOptions.slug}".`);
+    writeLine11(stdout, `Created schema "${data.slug ?? commandOptions.slug}".`);
   });
-  schemas.command("update").description("Update a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--name <name>", "schema name").option("--slug <slug>", "schema slug").option("--auditable <bool>", "auditable flag", parseBooleanFlag).option("--commentable <bool>", "commentable flag", parseBooleanFlag).action(async function action(schema, commandOptions) {
+  schemas.command("update").description("Update a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).option("--name <name>", "schema name").option("--slug <slug>", "schema slug").option("--auditable <bool>", "auditable flag", parseBooleanFlag).option("--commentable <bool>", "commentable flag", parseBooleanFlag).action(async function action(schema, commandOptions) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable7("schemas update", readOnly, "write");
+    ensureWritable8("schemas update", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const input = buildSchemaUpdateInput(commandOptions);
-    if (isEmptyObject5(input)) {
+    if (isEmptyObject6(input)) {
       throw new CliError(
         "invalid_cli_usage",
         'Provide at least one schema field to update via "--name", "--slug", "--auditable", or "--commentable".'
@@ -10455,14 +11079,14 @@ function registerSchemasCommands(program, options = {}) {
     }
     const data = await api.updateSchema(resolvedSchema, input);
     if (json) {
-      emitJson10(stdout, "schemas update", data, filePath);
+      emitJson11(stdout, "schemas update", data, filePath);
       return;
     }
-    writeLine10(stdout, `Updated schema "${data.slug ?? schema.value}".`);
+    writeLine11(stdout, `Updated schema "${data.slug ?? schema.value}".`);
   });
-  schemas.command("delete").description("Delete a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema) {
+  schemas.command("delete").description("Delete a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable7("schemas delete", readOnly, "destructive");
+    ensureWritable8("schemas delete", readOnly, "destructive");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     await api.deleteSchema(resolvedSchema);
     const data = {
@@ -10470,36 +11094,36 @@ function registerSchemasCommands(program, options = {}) {
       deleted: true
     };
     if (json) {
-      emitJson10(stdout, "schemas delete", data, filePath);
+      emitJson11(stdout, "schemas delete", data, filePath);
       return;
     }
-    writeLine10(stdout, `Deleted schema "${schema.value}".`);
+    writeLine11(stdout, `Deleted schema "${schema.value}".`);
   });
   const fields = schemas.command("fields").description("Manage schema fields");
-  fields.command("list").description("List fields for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema) {
+  fields.command("list").description("List fields for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema) {
     const { api, json } = createSchemasApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const data = await api.listFields(resolvedSchema);
     if (json) {
-      emitJson10(stdout, "schemas fields list", data, filePath);
+      emitJson11(stdout, "schemas fields list", data, filePath);
       return;
     }
     emitFieldsTable(stdout, data);
   });
-  fields.command("get").description("Get a field by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema, field) {
+  fields.command("get").description("Get a field by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema, field) {
     const { api, json } = createSchemasApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const resolvedField = await resolveFieldSelector(api, resolvedSchema, field);
     const data = await api.getField(resolvedSchema, resolvedField);
     if (json) {
-      emitJson10(stdout, "schemas fields get", data, filePath);
+      emitJson11(stdout, "schemas fields get", data, filePath);
       return;
     }
     emitFieldsTable(stdout, [data]);
   });
-  fields.command("create").description(`Create a field in a schema.${buildSchemaFieldCreateHelpText()}`).argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--type <type>", `field type (${formatSchemaFieldTypes()})`).option("--slug <slug>", "field slug").option("--label <label>", "field label").option("--required <bool>", "required flag", parseBooleanFlag).option("--default <value>", "default field value").option("--raw <json>", "raw JSON object payload (see type-specific shapes in --help)").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
+  fields.command("create").description(`Create a field in a schema.${buildSchemaFieldCreateHelpText()}`).argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).option("--type <type>", `field type (${formatSchemaFieldTypes()})`).option("--slug <slug>", "field slug").option("--label <label>", "field label").option("--required <bool>", "required flag", parseBooleanFlag).option("--default <value>", "default field value").option("--raw <json>", "raw JSON object payload (see type-specific shapes in --help)").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable7("schemas fields create", readOnly, "write");
+    ensureWritable8("schemas fields create", readOnly, "write");
     const input = buildFieldCreateInput(commandOptions);
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     let data;
@@ -10509,14 +11133,14 @@ function registerSchemasCommands(program, options = {}) {
       toFieldCreateError(error, input);
     }
     if (json) {
-      emitJson10(stdout, "schemas fields create", data, filePath);
+      emitJson11(stdout, "schemas fields create", data, filePath);
       return;
     }
-    writeLine10(stdout, `Created field "${data.slug ?? commandOptions.slug}".`);
+    writeLine11(stdout, `Created field "${data.slug ?? commandOptions.slug}".`);
   });
-  fields.command("update").description("Update a field in a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector8).option("--label <label>", "field label").option("--required <bool>", "required flag", parseBooleanFlag).option("--default <value>", "default field value").option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, field, commandOptions) {
+  fields.command("update").description("Update a field in a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector9).option("--label <label>", "field label").option("--required <bool>", "required flag", parseBooleanFlag).option("--default <value>", "default field value").option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, field, commandOptions) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable7("schemas fields update", readOnly, "write");
+    ensureWritable8("schemas fields update", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const resolvedField = await resolveFieldSelector(api, resolvedSchema, field);
     const currentField = await api.getField(resolvedSchema, resolvedField);
@@ -10525,7 +11149,7 @@ function registerSchemasCommands(program, options = {}) {
       throw new CliError("invalid_cli_usage", `Field "${field.value}" is missing type metadata.`);
     }
     const input = buildFieldUpdateInput(currentType, commandOptions);
-    if (isEmptyObject5(input)) {
+    if (isEmptyObject6(input)) {
       throw new CliError(
         "invalid_cli_usage",
         'Provide at least one field update via "--label", "--required", "--raw", or "--raw-file".'
@@ -10533,14 +11157,14 @@ function registerSchemasCommands(program, options = {}) {
     }
     const data = await api.updateField(resolvedSchema, resolvedField, input);
     if (json) {
-      emitJson10(stdout, "schemas fields update", data, filePath);
+      emitJson11(stdout, "schemas fields update", data, filePath);
       return;
     }
-    writeLine10(stdout, `Updated field "${data.slug ?? field.value}".`);
+    writeLine11(stdout, `Updated field "${data.slug ?? field.value}".`);
   });
-  fields.command("delete").description("Delete a field from a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema, field) {
+  fields.command("delete").description("Delete a field from a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema, field) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable7("schemas fields delete", readOnly, "destructive");
+    ensureWritable8("schemas fields delete", readOnly, "destructive");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const resolvedField = await resolveFieldSelector(api, resolvedSchema, field);
     await api.deleteField(resolvedSchema, resolvedField);
@@ -10550,19 +11174,19 @@ function registerSchemasCommands(program, options = {}) {
       deleted: true
     };
     if (json) {
-      emitJson10(stdout, "schemas fields delete", data, filePath);
+      emitJson11(stdout, "schemas fields delete", data, filePath);
       return;
     }
-    writeLine10(stdout, `Deleted field "${field.value}" from schema "${schema.value}".`);
+    writeLine11(stdout, `Deleted field "${field.value}" from schema "${schema.value}".`);
   });
 }
 
 // src/commands/teamspace.ts
-import { readFileSync as readFileSync9 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError9 } from "commander";
+import { readFileSync as readFileSync10 } from "fs";
+import { InvalidArgumentError as InvalidArgumentError10 } from "commander";
 
 // src/api/teamspace.ts
-function jsonOptions7(body, method) {
+function jsonOptions8(body, method) {
   return {
     method,
     headers: {
@@ -10571,7 +11195,7 @@ function jsonOptions7(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue9(selector) {
+function selectorValue10(selector) {
   return selector.value;
 }
 var TeamspaceApi = class {
@@ -10592,53 +11216,53 @@ var TeamspaceApi = class {
   createFolder(input) {
     return this.client.requestJson(
       "/api/v2/teamspaces/folders",
-      jsonOptions7(input, "POST")
+      jsonOptions8(input, "POST")
     );
   }
   updateFolder(folder, input) {
     return this.client.requestJson(
-      `/api/v2/teamspaces/folders/${selectorValue9(folder)}`,
-      jsonOptions7(input, "PATCH")
+      `/api/v2/teamspaces/folders/${selectorValue10(folder)}`,
+      jsonOptions8(input, "PATCH")
     );
   }
   deleteFolder(folder) {
     return this.client.requestJson(
-      `/api/v2/teamspaces/folders/${selectorValue9(folder)}`,
+      `/api/v2/teamspaces/folders/${selectorValue10(folder)}`,
       { method: "DELETE" }
     );
   }
   publishResource(input) {
     return this.client.requestJson(
       "/api/v2/teamspaces/resources:publish",
-      jsonOptions7(input, "POST")
+      jsonOptions8(input, "POST")
     );
   }
   unpublishResource(resourceId) {
     return this.client.requestJson(
       "/api/v2/teamspaces/resources:unpublish",
-      jsonOptions7({ resourceId }, "POST")
+      jsonOptions8({ resourceId }, "POST")
     );
   }
 };
 
 // src/commands/teamspace.ts
-function getCommandIo11(stdout) {
+function getCommandIo12(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine11(stdout, value) {
+function writeLine12(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions11(command) {
+function getGlobalOptions12(command) {
   return command.optsWithGlobals();
 }
-function emitJson11(stdout, commandName, data, configPath) {
-  writeLine11(
+function emitJson12(stdout, commandName, data, configPath) {
+  writeLine12(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath }))
   );
 }
-function toConfigurationError10(filePath, error) {
+function toConfigurationError11(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -10653,7 +11277,7 @@ function toConfigurationError10(filePath, error) {
 function createTeamspaceApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions11(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions12(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -10671,10 +11295,10 @@ function createTeamspaceApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError10(filePath, error);
+    toConfigurationError11(filePath, error);
   }
 }
-function ensureWritable8(commandName, readOnly, commandMode) {
+function ensureWritable9(commandName, readOnly, commandMode) {
   if (readOnly) {
     throw new CliError(
       "command_not_allowed_in_read_only_mode",
@@ -10686,21 +11310,21 @@ function ensureWritable8(commandName, readOnly, commandMode) {
     );
   }
 }
-function parseUuidOrSlugSelector9(input) {
+function parseUuidOrSlugSelector10(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError9(message);
+    throw new InvalidArgumentError10(message);
   }
 }
 function parseNonNegativeInteger3(input) {
   if (!/^\d+$/.test(input.trim())) {
-    throw new InvalidArgumentError9(`Expected a non-negative integer, received "${input}".`);
+    throw new InvalidArgumentError10(`Expected a non-negative integer, received "${input}".`);
   }
   return Number(input);
 }
-function isJsonObject7(value) {
+function isJsonObject8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseRawJsonObject4(input, sourceLabel) {
@@ -10714,7 +11338,7 @@ function parseRawJsonObject4(input, sourceLabel) {
       `Failed to parse JSON from ${sourceLabel}: ${message}`
     );
   }
-  if (!isJsonObject7(parsed)) {
+  if (!isJsonObject8(parsed)) {
     throw new CliError(
       "invalid_cli_usage",
       `Expected ${sourceLabel} to contain a JSON object.`
@@ -10735,7 +11359,7 @@ function readRawObject5(raw, rawFile) {
   if (rawFile) {
     let contents;
     try {
-      contents = readFileSync9(rawFile, "utf8");
+      contents = readFileSync10(rawFile, "utf8");
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unable to read file.";
       throw new CliError(
@@ -10747,7 +11371,7 @@ function readRawObject5(raw, rawFile) {
   }
   return void 0;
 }
-function isEmptyObject6(value) {
+function isEmptyObject7(value) {
   return Object.keys(value).length === 0;
 }
 function buildFolderCreateInput(options) {
@@ -10778,7 +11402,7 @@ function buildFolderUpdateInput(options) {
   if (props !== void 0) {
     input.additionalProperties = props;
   }
-  if (isEmptyObject6(input)) {
+  if (isEmptyObject7(input)) {
     throw new CliError(
       "invalid_cli_usage",
       'Provide folder updates via "--name", "--order", "--props", or "--props-file".'
@@ -10788,9 +11412,9 @@ function buildFolderUpdateInput(options) {
 }
 function toTableRows5(data) {
   if (Array.isArray(data)) {
-    return data.map((entry) => isJsonObject7(entry) ? entry : { value: entry });
+    return data.map((entry) => isJsonObject8(entry) ? entry : { value: entry });
   }
-  if (isJsonObject7(data)) {
+  if (isJsonObject8(data)) {
     return [data];
   }
   return [{ value: data }];
@@ -10852,85 +11476,85 @@ async function resolveFolderSelector2(api, selector) {
 }
 function registerTeamspaceCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo11(options.stdout);
+  const stdout = getCommandIo12(options.stdout);
   const teamspace = program.command("teamspace").description("Manage teamspace folders and resources");
   const folders = teamspace.command("folders").description("Manage teamspace folders");
   folders.command("list").description("List teamspace folders").option("--include-resources", "include nested resources").action(async function action(commandOptions) {
     const { api, json } = createTeamspaceApi(this, filePath);
     const data = await api.listFolders(Boolean(commandOptions.includeResources));
     if (json) {
-      emitJson11(stdout, "teamspace folders list", data, filePath);
+      emitJson12(stdout, "teamspace folders list", data, filePath);
       return;
     }
     emitTable5(stdout, data);
   });
-  folders.command("get").description("Get a teamspace folder by exact name or UUID").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector9).option("--include-resources", "include nested resources").action(async function action(folder, commandOptions) {
+  folders.command("get").description("Get a teamspace folder by exact name or UUID").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector10).option("--include-resources", "include nested resources").action(async function action(folder, commandOptions) {
     const { api, json } = createTeamspaceApi(this, filePath);
     const resolvedFolder = await resolveFolderSelector2(api, folder);
     const allFolders = await api.listFolders(Boolean(commandOptions.includeResources));
     const data = findFolderEntity(allFolders, resolvedFolder);
     if (json) {
-      emitJson11(stdout, "teamspace folders get", data, filePath);
+      emitJson12(stdout, "teamspace folders get", data, filePath);
       return;
     }
     emitTable5(stdout, data);
   });
   folders.command("create").description("Create a teamspace folder").requiredOption("--name <name>", "folder name").option("--order <n>", "folder order", parseNonNegativeInteger3).option("--props <json>", "folder properties payload").option("--props-file <path>", "path to a folder properties JSON payload").action(async function action(commandOptions) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
-    ensureWritable8("teamspace folders create", readOnly, "write");
+    ensureWritable9("teamspace folders create", readOnly, "write");
     const data = await api.createFolder(buildFolderCreateInput(commandOptions));
     if (json) {
-      emitJson11(stdout, "teamspace folders create", data, filePath);
+      emitJson12(stdout, "teamspace folders create", data, filePath);
       return;
     }
-    writeLine11(stdout, `Created folder "${getFolderIdentifier(data)}".`);
+    writeLine12(stdout, `Created folder "${getFolderIdentifier(data)}".`);
   });
-  folders.command("update").description("Update a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector9).option("--name <name>", "folder name").option("--order <n>", "folder order", parseNonNegativeInteger3).option("--props <json>", "folder properties payload").option("--props-file <path>", "path to a folder properties JSON payload").action(async function action(folder, commandOptions) {
+  folders.command("update").description("Update a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector10).option("--name <name>", "folder name").option("--order <n>", "folder order", parseNonNegativeInteger3).option("--props <json>", "folder properties payload").option("--props-file <path>", "path to a folder properties JSON payload").action(async function action(folder, commandOptions) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
-    ensureWritable8("teamspace folders update", readOnly, "write");
+    ensureWritable9("teamspace folders update", readOnly, "write");
     const resolvedFolder = await resolveFolderSelector2(api, folder);
     const data = await api.updateFolder(resolvedFolder, buildFolderUpdateInput(commandOptions));
     if (json) {
-      emitJson11(stdout, "teamspace folders update", data, filePath);
+      emitJson12(stdout, "teamspace folders update", data, filePath);
       return;
     }
-    writeLine11(stdout, `Updated folder "${getFolderIdentifier(data)}".`);
+    writeLine12(stdout, `Updated folder "${getFolderIdentifier(data)}".`);
   });
-  folders.command("delete").description("Delete a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector9).action(async function action(folder) {
+  folders.command("delete").description("Delete a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector10).action(async function action(folder) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
-    ensureWritable8("teamspace folders delete", readOnly, "destructive");
+    ensureWritable9("teamspace folders delete", readOnly, "destructive");
     const resolvedFolder = await resolveFolderSelector2(api, folder);
     const data = await api.deleteFolder(resolvedFolder);
     if (json) {
-      emitJson11(stdout, "teamspace folders delete", data, filePath);
+      emitJson12(stdout, "teamspace folders delete", data, filePath);
       return;
     }
-    writeLine11(stdout, `Deleted folder "${resolvedFolder.value}".`);
+    writeLine12(stdout, `Deleted folder "${resolvedFolder.value}".`);
   });
   const resources = teamspace.command("resources").description("Manage teamspace resources");
-  resources.command("publish").description("Publish a resource to a teamspace folder").argument("<resource>", "resource UUID or exact name", parseUuidOrSlugSelector9).requiredOption("--to <folder>", "target folder", parseUuidOrSlugSelector9).action(async function action(resource, commandOptions) {
+  resources.command("publish").description("Publish a resource to a teamspace folder").argument("<resource>", "resource UUID or exact name", parseUuidOrSlugSelector10).requiredOption("--to <folder>", "target folder", parseUuidOrSlugSelector10).action(async function action(resource, commandOptions) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
-    ensureWritable8("teamspace resources publish", readOnly, "write");
+    ensureWritable9("teamspace resources publish", readOnly, "write");
     const folder = await resolveFolderSelector2(api, commandOptions.to);
     const data = await api.publishResource({
       resourceId: resource.value,
       targetFolderId: folder.value
     });
     if (json) {
-      emitJson11(stdout, "teamspace resources publish", data, filePath);
+      emitJson12(stdout, "teamspace resources publish", data, filePath);
       return;
     }
-    writeLine11(stdout, `Published resource "${resource.value}" to folder "${folder.value}".`);
+    writeLine12(stdout, `Published resource "${resource.value}" to folder "${folder.value}".`);
   });
-  resources.command("unpublish").description("Unpublish a resource from teamspace").argument("<resource>", "resource UUID or exact name", parseUuidOrSlugSelector9).action(async function action(resource) {
+  resources.command("unpublish").description("Unpublish a resource from teamspace").argument("<resource>", "resource UUID or exact name", parseUuidOrSlugSelector10).action(async function action(resource) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
-    ensureWritable8("teamspace resources unpublish", readOnly, "write");
+    ensureWritable9("teamspace resources unpublish", readOnly, "write");
     const data = await api.unpublishResource(resource.value);
     if (json) {
-      emitJson11(stdout, "teamspace resources unpublish", data, filePath);
+      emitJson12(stdout, "teamspace resources unpublish", data, filePath);
       return;
     }
-    writeLine11(stdout, `Unpublished resource "${resource.value}".`);
+    writeLine12(stdout, `Unpublished resource "${resource.value}".`);
   });
 }
 
@@ -10938,12 +11562,13 @@ function registerTeamspaceCommands(program, options = {}) {
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 function buildProgram(options = {}) {
-  const program = new Command10();
+  const program = new Command11();
   program.name("zinkee").description("CLI for Zinkee API v2").version(version).enablePositionalOptions().showHelpAfterError().option("--profile <name>", "select a profile from config").option("--base-url <url>", "override the configured base URL").option("--api-key <token>", "override the configured API key").option("--read-only", "run in read-only mode").option("--example", "show examples for a command").option("--json", "emit JSON output").option("--install-completion [shell]", "install shell completion (bash, zsh, fish, powershell)").option("--show-completion [shell]", "print shell completion script for the current shell");
   registerProfilesCommands(program, options);
   registerAutomationsCommands(program, options);
   registerConfigCommands(program, options);
   registerDisplaysCommands(program, options);
+  registerDocumentTemplatesCommands(program, options);
   registerFilesCommands(program, options);
   registerNavigationCommands(program, options);
   registerSchemasCommands(program, options);
@@ -11088,9 +11713,9 @@ function getCompletions(program, request, deps = {}) {
 
 // src/completion/install.ts
 import { execFileSync } from "child_process";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "fs";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2, platform } from "os";
-import { basename as basename2, dirname as dirname2, join as join2 } from "path";
+import { basename as basename3, dirname as dirname2, join as join2 } from "path";
 
 // src/completion/scripts.ts
 var PROGRAM = "zinkee";
@@ -11212,7 +11837,7 @@ function defaultPowerShellProfile(env) {
 function detectShell(env) {
   const fromEnv = env.shellEnv;
   if (fromEnv) {
-    const name = basename2(fromEnv).toLowerCase().replace(/\.exe$/, "");
+    const name = basename3(fromEnv).toLowerCase().replace(/\.exe$/, "");
     if (name === "bash") {
       return "bash";
     }
@@ -11310,7 +11935,7 @@ ${BLOCK_END}
 }
 function readFileOrEmpty(path) {
   try {
-    return readFileSync10(path, "utf8");
+    return readFileSync11(path, "utf8");
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
       return "";
@@ -11320,7 +11945,7 @@ function readFileOrEmpty(path) {
 }
 function writeFileEnsuringDir(path, content) {
   mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync3(path, content, "utf8");
+  writeFileSync4(path, content, "utf8");
 }
 function installCompletion(shell, env) {
   const target = resolveTarget(shell, env);