zinkee 0.1.43 → 0.1.45

package/dist/chunk-MHEVRMDX.js

@@ -0,0 +1,1230 @@
+// src/utils/output.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function stringifyCellValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function buildJsonSuccess(data, meta = {}) {
+  return { data, meta };
+}
+function buildJsonError(error, meta = {}) {
+  return { error, meta };
+}
+var FOLDER_TABLE_KEYS = ["folderId", "folderName", "folderIsRoot"];
+function folderColumns(folder) {
+  if (!folder) {
+    return { folderId: "", folderName: "", folderIsRoot: "" };
+  }
+  return {
+    folderId: folder.id ?? "",
+    folderName: folder.name ?? (folder.isRoot === true ? "(root)" : ""),
+    folderIsRoot: folder.isRoot === void 0 ? "" : String(folder.isRoot)
+  };
+}
+function printTable(rows, keys, writer) {
+  const output = writer ?? process.stdout;
+  const firstRow = rows[0];
+  if (!firstRow) {
+    output.write("No results.\n");
+    return;
+  }
+  const headings = [...keys ?? Object.keys(firstRow)];
+  const Table = require2("cli-table3");
+  const table = new Table({
+    head: headings,
+    wordWrap: true
+  });
+  for (const row of rows) {
+    table.push(headings.map((heading) => stringifyCellValue(row[heading])));
+  }
+  output.write(`${table.toString()}
+`);
+}
+
+// src/client.ts
+import { Readable, Transform } from "stream";
+import { pipeline } from "stream/promises";
+var ApiClientError = class extends Error {
+  name = "ApiClientError";
+  code;
+  url;
+  method;
+  status;
+  responseBody;
+  responseText;
+  cause;
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.url = details.url;
+    this.method = details.method;
+    this.status = details.status;
+    this.responseBody = details.responseBody;
+    this.responseText = details.responseText;
+    this.cause = details.cause;
+  }
+};
+function isJsonContentType(contentType) {
+  return contentType ? /(^|\/|\+)json\b/i.test(contentType) : false;
+}
+function looksLikeJson(text) {
+  const trimmed = text.trim();
+  return trimmed.startsWith("{") || trimmed.startsWith("[") || trimmed === "null" || trimmed === "true" || trimmed === "false" || /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?$/.test(trimmed) || trimmed.startsWith('"');
+}
+function parseJsonBody(text, url, method) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch (cause) {
+    throw new ApiClientError("invalid_json", `Failed to parse JSON response from ${method} ${url}.`, {
+      url,
+      method,
+      responseText: text,
+      cause
+    });
+  }
+}
+function parseErrorBody(text, contentType) {
+  if (text.trim().length === 0) {
+    return void 0;
+  }
+  if (!isJsonContentType(contentType) && !looksLikeJson(text)) {
+    return text;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function summarizeNetworkCause(cause) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = cause;
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const candidate = current;
+    const message = typeof candidate.message === "string" ? candidate.message.trim() : "";
+    const code = typeof candidate.code === "string" ? candidate.code : void 0;
+    if (message && message !== "fetch failed") {
+      return code && !message.includes(code) ? `${message} (${code})` : message;
+    }
+    current = candidate.cause;
+  }
+  return void 0;
+}
+var ApiClient = class {
+  constructor(options) {
+    this.options = options;
+    this.fetchImpl = options.fetch ?? fetch;
+  }
+  fetchImpl;
+  getJson(path, init = {}) {
+    return this.requestJson(path, { ...init, method: "GET" });
+  }
+  requestJson(path, init = {}) {
+    return this.request(
+      path,
+      init,
+      async (response, url) => {
+        const text = await response.text();
+        return parseJsonBody(text, url, init.method ?? "GET");
+      },
+      "application/json"
+    );
+  }
+  download(path, destination, init = {}) {
+    return this.request(path, init, async (response, _url, signal) => {
+      let bytes = 0;
+      const counter = new Transform({
+        transform(chunk, _encoding, callback) {
+          bytes += chunk.length;
+          callback(null, chunk);
+        }
+      });
+      const source = response.body ? Readable.fromWeb(response.body) : Readable.from([]);
+      await pipeline(source, counter, destination, { signal });
+      return bytes;
+    });
+  }
+  buildUrl(path) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    return new URL(normalizedPath, this.options.baseUrl).toString();
+  }
+  async request(path, init, consume, accept) {
+    const url = this.buildUrl(path);
+    const method = init.method ?? "GET";
+    const headers = new Headers(init.headers);
+    if (accept && !headers.has("accept")) {
+      headers.set("accept", accept);
+    }
+    if (this.options.apiKey && !headers.has("authorization")) {
+      headers.set("authorization", `Bearer ${this.options.apiKey}`);
+    }
+    const controller = new AbortController();
+    const timeoutMs = init.timeoutMs ?? this.options.timeoutMs;
+    let timedOut = false;
+    let timeoutHandle;
+    const abortListener = () => {
+      controller.abort(init.signal?.reason);
+    };
+    if (init.signal) {
+      if (init.signal.aborted) {
+        controller.abort(init.signal.reason);
+      } else {
+        init.signal.addEventListener("abort", abortListener, { once: true });
+      }
+    }
+    if (timeoutMs !== void 0) {
+      timeoutHandle = setTimeout(() => {
+        if (!controller.signal.aborted) {
+          timedOut = true;
+          controller.abort();
+        }
+      }, timeoutMs);
+    }
+    try {
+      controller.signal.throwIfAborted();
+      const response = await this.fetchImpl(url, {
+        ...init,
+        headers,
+        signal: controller.signal
+      });
+      const responseUrl = response.url || url;
+      if (!response.ok) {
+        const text = await response.text();
+        throw this.buildHttpError(response, text, init, responseUrl);
+      }
+      return await consume(response, responseUrl, controller.signal);
+    } catch (cause) {
+      if (cause instanceof ApiClientError) {
+        throw cause;
+      }
+      if (timedOut) {
+        throw new ApiClientError("timeout", `Request timed out after ${timeoutMs}ms.`, {
+          url,
+          method,
+          cause
+        });
+      }
+      const causeSummary = summarizeNetworkCause(cause);
+      const message = causeSummary ? `Request failed for ${method} ${url}: ${causeSummary}.` : `Request failed for ${method} ${url}.`;
+      throw new ApiClientError("network_error", message, {
+        url,
+        method,
+        cause
+      });
+    } finally {
+      if (timeoutHandle !== void 0) {
+        clearTimeout(timeoutHandle);
+      }
+      if (init.signal) {
+        init.signal.removeEventListener("abort", abortListener);
+      }
+    }
+  }
+  buildHttpError(response, text, init, url) {
+    const method = init.method ?? "GET";
+    const responseBody = parseErrorBody(text, response.headers.get("content-type"));
+    return new ApiClientError(
+      "http_error",
+      `Request failed with status ${response.status} for ${method} ${url}.`,
+      {
+        url,
+        method,
+        status: response.status,
+        responseBody,
+        responseText: responseBody === text ? text : void 0
+      }
+    );
+  }
+};
+
+// src/utils/errors.ts
+var cliExitCodeByErrorCode = {
+  unknown_error: 1,
+  invalid_cli_usage: 2,
+  configuration_error: 2,
+  command_not_allowed_in_read_only_mode: 7,
+  network_error: 1,
+  http_error: 1,
+  timeout: 1,
+  invalid_json: 1
+};
+var errorCodeByName = {
+  ProfileResolutionError: "configuration_error"
+};
+var CliError = class extends Error {
+  name = "CliError";
+  code;
+  exitCode;
+  details;
+  constructor(code, message, details = {}, exitCode = cliExitCodeByErrorCode[code]) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    if (Object.keys(details).length > 0) {
+      this.details = details;
+    }
+  }
+  toJSON() {
+    const payload = {
+      code: this.code,
+      message: this.message,
+      exitCode: this.exitCode
+    };
+    if (this.details) {
+      payload.details = this.details;
+    }
+    return payload;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function extractApiErrorDetails(error) {
+  const details = {};
+  const meta = {};
+  const responseBody = isRecord(error.responseBody) ? error.responseBody : void 0;
+  const errorBody = responseBody?.error;
+  const backendError = isRecord(errorBody) ? errorBody : responseBody;
+  const backendMeta = isRecord(responseBody?.meta) ? responseBody.meta : void 0;
+  const reason = readString(backendError?.reason) ?? readString(backendError?.code);
+  const action = readString(backendError?.action);
+  const requestId = readString(backendMeta?.requestId) ?? readString(responseBody?.requestId) ?? readString(backendError?.requestId);
+  const status = readNumber(backendError?.status) ?? readNumber(responseBody?.status) ?? error.status;
+  const backendMessage = readString(backendError?.message);
+  if (reason !== void 0) {
+    details.reason = reason;
+  }
+  if (action !== void 0) {
+    details.action = action;
+  }
+  if (requestId !== void 0) {
+    details.requestId = requestId;
+    meta.requestId = requestId;
+  }
+  if (status !== void 0) {
+    details.status = status;
+    meta.status = status;
+  }
+  return {
+    message: backendMessage ?? error.message,
+    details,
+    meta
+  };
+}
+function toCliError(error) {
+  if (error instanceof CliError) {
+    return error;
+  }
+  if (error instanceof ApiClientError) {
+    const apiError = extractApiErrorDetails(error);
+    return new CliError(error.code, apiError.message, apiError.details);
+  }
+  if (error instanceof Error) {
+    return new CliError(errorCodeByName[error.name] ?? "unknown_error", error.message);
+  }
+  return new CliError("unknown_error", "Unknown error");
+}
+function getExitCode(error) {
+  return toCliError(error).exitCode;
+}
+function buildJsonCliError(error, meta = {}) {
+  const cliError = toCliError(error);
+  const apiErrorMeta = error instanceof ApiClientError ? extractApiErrorDetails(error).meta : {};
+  return buildJsonError(cliError.toJSON(), { ...apiErrorMeta, ...meta });
+}
+function formatCliErrorText(error) {
+  return toCliError(error).message;
+}
+function formatCliErrorJson(error, meta = {}) {
+  return JSON.stringify(buildJsonCliError(error, meta));
+}
+
+// src/utils/schema-fields.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toJsonObject(value) {
+  return isJsonObject(value) ? value : void 0;
+}
+function toStringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function toNumberValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+var fieldTypeDefinitions = [
+  {
+    key: "text",
+    className: "TextField",
+    aliases: ["text", "TextField"],
+    description: "Plain text field.",
+    rawShape: '{"type":"TextField","slug":"name","label":"Name","config":{"textType":"NORMAL"}}',
+    examplePayloads: [
+      {
+        name: "Text field (normal)",
+        payload: {
+          type: "TextField",
+          slug: "customer-name",
+          label: "Customer Name",
+          required: true,
+          config: {
+            textType: "NORMAL",
+            defaultValue: null,
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Text field (long)",
+        payload: {
+          type: "TextField",
+          slug: "customer-notes",
+          label: "Customer Notes",
+          required: false,
+          config: {
+            textType: "LONG",
+            defaultValue: "Add internal notes here...",
+            conditionalFormatting: []
+          }
+        }
+      }
+    ]
+  },
+  {
+    key: "number",
+    className: "NumberField",
+    aliases: ["number", "NumberField"],
+    description: "Numeric field.",
+    rawShape: '{"type":"NumberField","slug":"quantity","label":"Quantity","config":{"defaultValue":"0","formatOptions":{"format":"number","decimals":0,"thousandsSeparator":false}}}',
+    examplePayloads: [
+      {
+        name: "Number field (plain integer)",
+        payload: {
+          type: "NumberField",
+          slug: "quantity",
+          label: "Quantity",
+          required: false,
+          config: {
+            defaultValue: "0",
+            formatOptions: {
+              format: "number",
+              decimals: 0,
+              thousandsSeparator: false
+            },
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Number field (decimal with thousands)",
+        payload: {
+          type: "NumberField",
+          slug: "weight",
+          label: "Weight (kg)",
+          required: false,
+          config: {
+            defaultValue: "0",
+            formatOptions: {
+              format: "number",
+              decimals: 2,
+              thousandsSeparator: true,
+              negativesInRed: false
+            },
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Number field (currency \u20AC prefix)",
+        payload: {
+          type: "NumberField",
+          slug: "amount-eur",
+          label: "Amount (EUR)",
+          required: false,
+          config: {
+            defaultValue: "0",
+            formatOptions: {
+              format: "currency",
+              decimals: 2,
+              negativesInRed: true,
+              thousandsSeparator: true,
+              symbolEnabled: true,
+              symbolPosition: "before",
+              symbolValue: "\u20AC"
+            },
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Number field (currency $ suffix)",
+        payload: {
+          type: "NumberField",
+          slug: "amount-usd",
+          label: "Amount (USD)",
+          required: false,
+          config: {
+            defaultValue: "0",
+            formatOptions: {
+              format: "currency",
+              decimals: 2,
+              negativesInRed: false,
+              thousandsSeparator: true,
+              symbolEnabled: true,
+              symbolPosition: "right",
+              symbolValue: " $"
+            },
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Number field (percentage)",
+        payload: {
+          type: "NumberField",
+          slug: "discount-rate",
+          label: "Discount Rate",
+          required: false,
+          config: {
+            defaultValue: "0",
+            formatOptions: {
+              format: "percentage",
+              decimals: 1,
+              negativesInRed: true
+            },
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Number field (duration HH:MM)",
+        payload: {
+          type: "NumberField",
+          slug: "tracked-time",
+          label: "Tracked Time",
+          required: false,
+          config: {
+            defaultValue: "0",
+            formatOptions: {
+              format: "duration",
+              durationFormat: "HH:MM"
+            },
+            conditionalFormatting: []
+          }
+        }
+      }
+    ]
+  },
+  {
+    key: "date",
+    className: "DateField",
+    aliases: ["date", "DateField"],
+    description: "Date or datetime field.",
+    rawShape: '{"type":"DateField","slug":"due-date","label":"Due Date","config":{"formatOptions":{"format":"date","dateFormat":"YYYY-MM-DD","showTime":false}}}',
+    examplePayloads: [
+      {
+        name: "Date field (date only)",
+        payload: {
+          type: "DateField",
+          slug: "birth-date",
+          label: "Birth Date",
+          required: false,
+          config: {
+            defaultValue: null,
+            formatOptions: {
+              format: "date",
+              dateFormat: "YYYY-MM-DD",
+              showTime: false
+            },
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Date field (datetime EU)",
+        payload: {
+          type: "DateField",
+          slug: "due-date",
+          label: "Due Date",
+          required: false,
+          config: {
+            defaultValue: null,
+            formatOptions: {
+              format: "datetime",
+              dateFormat: "DD/MM/YYYY",
+              showTime: true
+            },
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Date field (datetime US)",
+        payload: {
+          type: "DateField",
+          slug: "appointment-at",
+          label: "Appointment",
+          required: false,
+          config: {
+            defaultValue: null,
+            formatOptions: {
+              format: "datetime",
+              dateFormat: "MM/DD/YYYY",
+              showTime: true
+            },
+            conditionalFormatting: []
+          }
+        }
+      }
+    ]
+  },
+  {
+    key: "option",
+    className: "OptionField",
+    aliases: ["option", "OptionField"],
+    description: "Dropdown/select field with options.",
+    rawShape: '{"type":"OptionField","slug":"status","label":"Status","config":{"options":[{"id":1,"name":"Open","color":"default"},{"id":2,"name":"Closed","color":"success"}]}}',
+    examplePayloads: [
+      {
+        name: "Option field (select dropdown)",
+        payload: {
+          type: "OptionField",
+          slug: "priority",
+          label: "Priority",
+          required: false,
+          config: {
+            options: [
+              { id: 1, name: "Low", color: "default" },
+              { id: 2, name: "Medium", color: "warning" },
+              { id: 3, name: "High", color: "danger" }
+            ],
+            defaultValue: 1,
+            conditionalFormatting: [],
+            buttonConfig: null
+          }
+        }
+      },
+      {
+        name: "Option field (button cycle)",
+        payload: {
+          type: "OptionField",
+          slug: "stage",
+          label: "Stage",
+          required: false,
+          config: {
+            options: [
+              { id: 1, name: "To Do", color: "default" },
+              { id: 2, name: "Doing", color: "warning" },
+              { id: 3, name: "Done", color: "success" }
+            ],
+            defaultValue: 1,
+            conditionalFormatting: [],
+            buttonConfig: {
+              displayMode: "button",
+              buttonBehavior: {
+                mode: "cycle",
+                cycleOrder: [1, 2, 3],
+                requireConfirmation: false,
+                lockAfterSelection: false,
+                allowReselect: true
+              }
+            }
+          }
+        }
+      },
+      {
+        name: "Option field (button dropdown w/ confirm)",
+        payload: {
+          type: "OptionField",
+          slug: "status",
+          label: "Status",
+          required: false,
+          config: {
+            options: [
+              { id: 1, name: "Open", color: "default" },
+              { id: 2, name: "In Progress", color: "warning" },
+              { id: 3, name: "Done", color: "success" }
+            ],
+            defaultValue: 1,
+            conditionalFormatting: [],
+            buttonConfig: {
+              displayMode: "button",
+              buttonBehavior: {
+                mode: "dropdown",
+                requireConfirmation: true,
+                confirmationMessage: "Confirm status change",
+                useFixedLabel: true,
+                buttonLabel: "Set status",
+                allowReselect: true
+              }
+            }
+          }
+        }
+      }
+    ]
+  },
+  {
+    key: "file",
+    className: "FileField",
+    aliases: ["file", "FileField"],
+    description: "File attachment field.",
+    rawShape: '{"type":"FileField","slug":"attachment","label":"Attachment","config":{}}',
+    examplePayloads: [
+      {
+        name: "File field",
+        payload: {
+          type: "FileField",
+          slug: "attachment",
+          label: "Attachment",
+          required: false,
+          config: {}
+        }
+      }
+    ]
+  },
+  {
+    key: "reference",
+    className: "ReferenceField",
+    aliases: ["reference", "ReferenceField"],
+    description: "Reference to another schema.",
+    rawShape: '{"type":"ReferenceField","slug":"company-ref","label":"Company","config":{"targetSchema":"<schema-uuid>","targetDisplayField":"<field-uuid>"}}',
+    examplePayloads: [
+      {
+        name: "Reference field (minimal)",
+        payload: {
+          type: "ReferenceField",
+          slug: "company-ref",
+          label: "Company",
+          required: false,
+          config: {
+            targetSchema: "5223cbc8-8c6c-4694-93bc-dd176364df9b",
+            targetDisplayField: "c60b8526-5835-4c9f-aecd-9a16c7704a34"
+          }
+        }
+      },
+      {
+        name: "Reference field (restrict + filter + description)",
+        payload: {
+          type: "ReferenceField",
+          slug: "customer-ref",
+          label: "Customer",
+          required: false,
+          config: {
+            targetSchema: "5223cbc8-8c6c-4694-93bc-dd176364df9b",
+            targetDisplayField: "c60b8526-5835-4c9f-aecd-9a16c7704a34",
+            deleteBehavior: "RESTRICT",
+            defaultValue: "CUST-12",
+            filterFields: [
+              {
+                fatherField: "c60b8526-5835-4c9f-aecd-9a16c7704a34",
+                currentField: "45c5da96-0dc2-4cc1-ba61-7660a9c6da32",
+                comparison: "EQUAL",
+                value: null
+              }
+            ],
+            descriptionFields: [
+              {
+                id: "c52efe3f-2825-4c60-a7e3-34dd4c1ce043",
+                fieldType: "NumberField",
+                options: null,
+                format: "number"
+              }
+            ],
+            conditionalFormatting: []
+          }
+        }
+      }
+    ]
+  },
+  {
+    key: "formula",
+    className: "FormulaField",
+    aliases: ["formula", "FormulaField"],
+    description: "Calculated field from a formula.",
+    rawShape: '{"type":"FormulaField","slug":"formula-code","label":"Formula Code","config":{"formulaText":"concat(\\"CUST-\\", f1e1d000-0000-0000-0000-000000000005)","uiFormatKind":"none"}}',
+    examplePayloads: [
+      {
+        name: "Formula field (none)",
+        payload: {
+          type: "FormulaField",
+          slug: "formula-code",
+          label: "Formula Code",
+          required: false,
+          config: {
+            formulaText: 'concat("CUST-", f1e1d000-0000-0000-0000-000000000005)',
+            uiFormatKind: "none",
+            status: "ACTIVE",
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Formula field (number)",
+        payload: {
+          type: "FormulaField",
+          slug: "formula-total",
+          label: "Formula Total",
+          required: false,
+          config: {
+            formulaText: "c52efe3f-2825-4c60-a7e3-34dd4c1ce043 * 1.21",
+            uiFormatKind: "number",
+            status: "ACTIVE",
+            numberFormatOptions: {
+              format: "number",
+              decimals: 2,
+              thousandsSeparator: true
+            },
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Formula field (date)",
+        payload: {
+          type: "FormulaField",
+          slug: "formula-period",
+          label: "Formula Period",
+          required: false,
+          config: {
+            formulaText: 'date_format(d4e5f6a7-b8c9-0d1e-2f3a-4b5c6d7e8f90, "AAAA-MM")',
+            uiFormatKind: "date",
+            status: "ACTIVE",
+            dateFormatOptions: {
+              format: "date",
+              dateFormat: "DD/MM/YYYY",
+              showTime: false
+            },
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Formula field (member)",
+        payload: {
+          type: "FormulaField",
+          slug: "formula-assignee",
+          label: "Computed Assignee",
+          required: false,
+          config: {
+            formulaText: "a7b8c9d0-e1f2-3a4b-5c6d-7e8f90123456",
+            uiFormatKind: "member",
+            status: "ACTIVE",
+            conditionalFormatting: []
+          }
+        }
+      }
+    ]
+  },
+  {
+    key: "member",
+    className: "MemberField",
+    aliases: ["member", "MemberField"],
+    description: "Workspace member field.",
+    rawShape: '{"type":"MemberField","slug":"owner","label":"Owner","config":{"defaultValue":null}}',
+    examplePayloads: [
+      {
+        name: "Member field",
+        payload: {
+          type: "MemberField",
+          slug: "owner",
+          label: "Owner",
+          required: false,
+          config: {
+            defaultValue: null,
+            conditionalFormatting: []
+          }
+        }
+      }
+    ]
+  },
+  {
+    key: "autoincremental",
+    className: "AutoIncrementalField",
+    aliases: [
+      "autoincremental",
+      "auto-incremental",
+      "auto_incremental",
+      "AutoIncrementalField"
+    ],
+    description: "Auto-generated incremental counter.",
+    rawShape: '{"type":"AutoIncrementalField","slug":"order-number","label":"Order Number","config":{"segmentedByFieldId":null}}',
+    examplePayloads: [
+      {
+        name: "Autoincremental (global counter)",
+        payload: {
+          type: "AutoIncrementalField",
+          slug: "order-number",
+          label: "Order Number",
+          required: false,
+          config: {
+            segmentedByFieldId: null,
+            conditionalFormatting: []
+          }
+        }
+      },
+      {
+        name: "Autoincremental (segmented)",
+        payload: {
+          type: "AutoIncrementalField",
+          slug: "sequence-code",
+          label: "Sequence Code",
+          required: false,
+          config: {
+            segmentedByFieldId: "45c5da96-0dc2-4cc1-ba61-7660a9c6da32",
+            conditionalFormatting: []
+          }
+        }
+      }
+    ]
+  },
+  {
+    key: "schedule",
+    className: "ScheduleField",
+    aliases: ["schedule", "ScheduleField"],
+    description: "Recurrence/schedule field bound to a number reference and a date period (frequency: monthly or daily).",
+    rawShape: '{"type":"ScheduleField","slug":"recurrence","label":"Recurrence","config":{"referenceField":"<number-field-uuid>","beginningPeriodField":"<date-field-uuid>","endingPeriodField":"<date-field-uuid>","frequency":"monthly"}}',
+    examplePayloads: [
+      {
+        name: "Schedule field (monthly)",
+        payload: {
+          type: "ScheduleField",
+          slug: "monthly-recurrence",
+          label: "Monthly Recurrence",
+          required: false,
+          config: {
+            referenceField: "c52efe3f-2825-4c60-a7e3-34dd4c1ce043",
+            beginningPeriodField: "d4e5f6a7-b8c9-0d1e-2f3a-4b5c6d7e8f90",
+            endingPeriodField: "d4e5f6a7-b8c9-0d1e-2f3a-4b5c6d7e8f90",
+            frequency: "monthly"
+          }
+        }
+      },
+      {
+        name: "Schedule field (daily)",
+        payload: {
+          type: "ScheduleField",
+          slug: "daily-recurrence",
+          label: "Daily Recurrence",
+          required: false,
+          config: {
+            referenceField: "c52efe3f-2825-4c60-a7e3-34dd4c1ce043",
+            beginningPeriodField: "d4e5f6a7-b8c9-0d1e-2f3a-4b5c6d7e8f90",
+            endingPeriodField: "d4e5f6a7-b8c9-0d1e-2f3a-4b5c6d7e8f90",
+            frequency: "daily"
+          }
+        }
+      }
+    ]
+  }
+];
+var fieldTypeDefinitionByAlias = new Map(
+  fieldTypeDefinitions.flatMap(
+    (definition) => definition.aliases.map((alias) => [alias.trim().toLowerCase(), definition])
+  )
+);
+var fieldTypeDefinitionByClassName = new Map(
+  fieldTypeDefinitions.map((definition) => [definition.className, definition])
+);
+var optionValidationMessage = 'Option fields require an "options" array with at least one entry like {"id":1,"name":"Open","color":"default"}.';
+function getSchemaFieldTypeDefinitions() {
+  return fieldTypeDefinitions;
+}
+function listSchemaFieldTypes() {
+  return fieldTypeDefinitions.map((definition) => definition.key);
+}
+function formatSchemaFieldTypes() {
+  return listSchemaFieldTypes().join(", ");
+}
+function resolveSchemaFieldType(input) {
+  if (!input) {
+    return void 0;
+  }
+  return fieldTypeDefinitionByAlias.get(input.trim().toLowerCase());
+}
+function resolveSchemaFieldTypeByClassName(className) {
+  if (!className) {
+    return void 0;
+  }
+  return fieldTypeDefinitionByClassName.get(className);
+}
+function normalizeSchemaFieldType(input) {
+  const definition = resolveSchemaFieldType(input);
+  if (definition) {
+    return definition.className;
+  }
+  if (/^[a-z]/.test(input) && !input.endsWith("Field")) {
+    return `${input.charAt(0).toUpperCase()}${input.slice(1)}Field`;
+  }
+  return input;
+}
+function assertSupportedSchemaFieldType(type) {
+  if (!resolveSchemaFieldTypeByClassName(type)) {
+    throw new CliError(
+      "invalid_cli_usage",
+      `Unsupported field type "${type}". Valid types: ${formatSchemaFieldTypes()}.`
+    );
+  }
+}
+function normalizeOptionEntries(entries) {
+  return entries.flatMap((entry) => {
+    if (!isJsonObject(entry)) {
+      return [];
+    }
+    const id = toNumberValue(entry.id);
+    const name = toStringValue(entry.name) ?? toStringValue(entry.label);
+    const color = toStringValue(entry.color) ?? "default";
+    if (id === void 0 || !name) {
+      return [];
+    }
+    return [{ id, name, color }];
+  });
+}
+function normalizeOptionPayload(input) {
+  const additionalProperties = toJsonObject(input.additionalProperties) ?? {};
+  const config = toJsonObject(input.config);
+  const rootOptions = Array.isArray(input.options) ? input.options : void 0;
+  const nestedOptions = Array.isArray(additionalProperties.options) ? additionalProperties.options : Array.isArray(config?.options) ? config.options : void 0;
+  const optionObjects = normalizeOptionEntries(
+    nestedOptions ?? (Array.isArray(rootOptions) ? rootOptions : [])
+  );
+  if (optionObjects.length === 0) {
+    throw new CliError("invalid_cli_usage", optionValidationMessage);
+  }
+  const { options: _options, additionalProperties: _additionalProperties, ...rest } = input;
+  const defaultValue = config?.defaultValue ?? input.defaultValue ?? additionalProperties.defaultValue;
+  const conditionalFormatting = config?.conditionalFormatting ?? additionalProperties.conditionalFormatting;
+  const buttonConfig = config?.buttonConfig ?? additionalProperties.buttonConfig;
+  return {
+    ...rest,
+    config: {
+      ...config ?? {},
+      options: optionObjects,
+      ...defaultValue !== void 0 ? { defaultValue } : {},
+      ...conditionalFormatting !== void 0 ? { conditionalFormatting } : {},
+      ...buttonConfig !== void 0 ? { buttonConfig } : {}
+    }
+  };
+}
+function normalizeReferencePayload(input) {
+  const additionalProperties = toJsonObject(input.additionalProperties) ?? {};
+  const config = toJsonObject(input.config) ?? {};
+  const targetSchema = config.targetSchema ?? input.targetSchema ?? additionalProperties.targetSchema;
+  const targetDisplayField = config.targetDisplayField ?? input.targetDisplayField ?? additionalProperties.targetDisplayField;
+  const deleteBehavior = config.deleteBehavior ?? input.deleteBehavior ?? additionalProperties.deleteBehavior;
+  const defaultValue = config.defaultValue ?? input.defaultValue ?? additionalProperties.defaultValue;
+  const filterFields = config.filterFields ?? input.filterFields ?? additionalProperties.filterFields;
+  const descriptionFields = config.descriptionFields ?? input.descriptionFields ?? additionalProperties.descriptionFields;
+  const conditionalFormatting = config.conditionalFormatting ?? input.conditionalFormatting ?? additionalProperties.conditionalFormatting;
+  const normalized = {
+    ...input
+  };
+  normalized.config = {
+    ...config,
+    ...targetSchema !== void 0 ? { targetSchema } : {},
+    ...targetDisplayField !== void 0 ? { targetDisplayField } : {},
+    ...deleteBehavior !== void 0 ? { deleteBehavior } : {},
+    ...defaultValue !== void 0 ? { defaultValue } : {},
+    ...filterFields !== void 0 ? { filterFields } : {},
+    ...descriptionFields !== void 0 ? { descriptionFields } : {},
+    ...conditionalFormatting !== void 0 ? { conditionalFormatting } : {}
+  };
+  const normalizedConfig = toJsonObject(normalized.config) ?? {};
+  if (!toStringValue(normalizedConfig.targetSchema) || !toStringValue(normalizedConfig.targetDisplayField)) {
+    const definition = resolveSchemaFieldType("reference");
+    throw new CliError(
+      "invalid_cli_usage",
+      `Reference fields require "targetSchema" and "targetDisplayField". Expected raw shape: ${definition.rawShape}`
+    );
+  }
+  return normalized;
+}
+var scheduleAllowedFrequencies = /* @__PURE__ */ new Set(["monthly", "daily"]);
+function normalizeSchedulePayload(input) {
+  const additionalProperties = toJsonObject(input.additionalProperties) ?? {};
+  const config = toJsonObject(input.config) ?? {};
+  const referenceField = config.referenceField ?? input.referenceField ?? additionalProperties.referenceField;
+  const beginningPeriodField = config.beginningPeriodField ?? input.beginningPeriodField ?? additionalProperties.beginningPeriodField;
+  const endingPeriodField = config.endingPeriodField ?? input.endingPeriodField ?? additionalProperties.endingPeriodField;
+  const frequency = config.frequency ?? input.frequency ?? additionalProperties.frequency;
+  const {
+    referenceField: _referenceField,
+    beginningPeriodField: _beginningPeriodField,
+    endingPeriodField: _endingPeriodField,
+    frequency: _frequency,
+    additionalProperties: _additionalProperties,
+    ...rest
+  } = input;
+  const normalized = {
+    ...rest,
+    config: {
+      ...config,
+      ...referenceField !== void 0 ? { referenceField } : {},
+      ...beginningPeriodField !== void 0 ? { beginningPeriodField } : {},
+      ...endingPeriodField !== void 0 ? { endingPeriodField } : {},
+      ...frequency !== void 0 ? { frequency } : {}
+    }
+  };
+  const normalizedConfig = toJsonObject(normalized.config) ?? {};
+  const definition = resolveSchemaFieldType("schedule");
+  if (!toStringValue(normalizedConfig.referenceField) || !toStringValue(normalizedConfig.beginningPeriodField) || !toStringValue(normalizedConfig.endingPeriodField) || !toStringValue(normalizedConfig.frequency)) {
+    throw new CliError(
+      "invalid_cli_usage",
+      `Schedule fields require "referenceField", "beginningPeriodField", "endingPeriodField" and "frequency". Expected raw shape: ${definition.rawShape}`
+    );
+  }
+  const frequencyValue = toStringValue(normalizedConfig.frequency);
+  if (!scheduleAllowedFrequencies.has(frequencyValue)) {
+    throw new CliError(
+      "invalid_cli_usage",
+      `Schedule "frequency" must be "monthly" or "daily" (received "${frequencyValue}").`
+    );
+  }
+  return normalized;
+}
+function normalizeFormulaPayload(input) {
+  const { status: _status, ...rest } = input;
+  const rawAdditionalProperties = toJsonObject(input.additionalProperties);
+  const rawConfig = toJsonObject(input.config);
+  const { status: _additionalStatus, ...additionalProperties } = rawAdditionalProperties ?? {};
+  const { status: _configStatus, ...config } = rawConfig ?? {};
+  const formulaText = config.formulaText ?? rest.formulaText ?? rest.expression ?? additionalProperties.formulaText ?? additionalProperties.expression;
+  const normalized = {
+    ...rest
+  };
+  normalized.config = {
+    ...config,
+    ...formulaText !== void 0 ? { formulaText } : {},
+    ...config.uiFormatKind !== void 0 ? { uiFormatKind: config.uiFormatKind } : {},
+    ...config.defaultValue !== void 0 ? { defaultValue: config.defaultValue } : {},
+    ...config.numberFormatOptions !== void 0 ? { numberFormatOptions: config.numberFormatOptions } : {},
+    ...config.dateFormatOptions !== void 0 ? { dateFormatOptions: config.dateFormatOptions } : {},
+    ...config.conditionalFormatting !== void 0 ? { conditionalFormatting: config.conditionalFormatting } : {}
+  };
+  const normalizedConfig = toJsonObject(normalized.config) ?? {};
+  if (!toStringValue(normalizedConfig.formulaText)) {
+    const definition = resolveSchemaFieldType("formula");
+    throw new CliError(
+      "invalid_cli_usage",
+      `Formula fields require "formulaText". Expected raw shape: ${definition.rawShape}`
+    );
+  }
+  return normalized;
+}
+function normalizeSchemaFieldCreatePayload(input) {
+  const rawType = toStringValue(input.type);
+  const normalizedType = rawType ? normalizeSchemaFieldType(rawType) : void 0;
+  const definition = resolveSchemaFieldTypeByClassName(normalizedType);
+  if (!definition) {
+    return input;
+  }
+  const normalizedWithType = {
+    ...input,
+    type: definition.className
+  };
+  switch (definition.key) {
+    case "option":
+      return normalizeOptionPayload(normalizedWithType);
+    case "reference":
+      return normalizeReferencePayload(normalizedWithType);
+    case "formula":
+      return normalizeFormulaPayload(normalizedWithType);
+    case "schedule":
+      return normalizeSchedulePayload(normalizedWithType);
+    case "autoincremental": {
+      const config = toJsonObject(normalizedWithType.config) ?? {};
+      const segmentedByFieldId = config.segmentedByFieldId ?? normalizedWithType.segmentedByFieldId ?? null;
+      return {
+        ...normalizedWithType,
+        config: {
+          ...config,
+          segmentedByFieldId,
+          ...config.conditionalFormatting !== void 0 ? { conditionalFormatting: config.conditionalFormatting } : {}
+        }
+      };
+    }
+    default:
+      return normalizedWithType;
+  }
+}
+function normalizeSchemaFieldUpdatePayload(type, input) {
+  const definition = resolveSchemaFieldTypeByClassName(type);
+  if (definition?.key === "formula") {
+    return normalizeFormulaPayload(input);
+  }
+  return input;
+}
+function buildSchemaFieldCreateHelpText() {
+  const sections = fieldTypeDefinitions.map(
+    (definition) => `  - ${definition.key}: ${definition.description}
+    raw: ${definition.rawShape}`
+  );
+  return [
+    "",
+    "Valid field types:",
+    `  ${formatSchemaFieldTypes()}`,
+    "",
+    "Raw payload shapes by type:",
+    ...sections,
+    "",
+    'Use "zinkee --example schemas fields create --type <type>" to show a concrete example for one type.'
+  ].join("\n");
+}
+function buildSchemaFieldCreateValidationMessage(type) {
+  const definition = resolveSchemaFieldTypeByClassName(type);
+  if (!definition) {
+    return `Invalid payload for field type "${type}". Valid types: ${formatSchemaFieldTypes()}.`;
+  }
+  return `Invalid payload for field type "${definition.key}". Expected raw shape: ${definition.rawShape}`;
+}
+
+export {
+  ApiClientError,
+  ApiClient,
+  buildJsonSuccess,
+  FOLDER_TABLE_KEYS,
+  folderColumns,
+  printTable,
+  CliError,
+  getExitCode,
+  formatCliErrorText,
+  formatCliErrorJson,
+  getSchemaFieldTypeDefinitions,
+  formatSchemaFieldTypes,
+  resolveSchemaFieldType,
+  normalizeSchemaFieldType,
+  assertSupportedSchemaFieldType,
+  normalizeSchemaFieldCreatePayload,
+  normalizeSchemaFieldUpdatePayload,
+  buildSchemaFieldCreateHelpText,
+  buildSchemaFieldCreateValidationMessage
+};
+//# sourceMappingURL=chunk-MHEVRMDX.js.map