@dokus/client 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1424 @@
+import { DokusValidationError, DokusAbortError, DokusTimeoutError, DokusConnectionError, DokusWaitTimeoutError, DokusProtocolError, DokusResponseTooLargeError, DokusApiError } from './chunk-RJGJ7P2Y.js';
+export { DokusAbortError, DokusApiError, DokusConnectionError, DokusError, DokusProtocolError, DokusResponseTooLargeError, DokusTimeoutError, DokusValidationError, DokusWaitTimeoutError } from './chunk-RJGJ7P2Y.js';
+import { randomUUID } from 'crypto';
+
+// src/validation.ts
+var OPAQUE_ID_PATTERN = /^[A-Za-z0-9._:-]{8,128}$/;
+var UUID_PATTERN = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+function assertExactDataObject(value, allowedKeys, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new DokusValidationError(`${label} must be a plain data object.`);
+  }
+  let prototype;
+  let descriptors2;
+  try {
+    prototype = Object.getPrototypeOf(value);
+    descriptors2 = Object.getOwnPropertyDescriptors(value);
+  } catch {
+    throw new DokusValidationError(`${label} must be a plain data object.`);
+  }
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new DokusValidationError(`${label} must be a plain data object.`);
+  }
+  for (const key of Reflect.ownKeys(descriptors2)) {
+    const descriptor = descriptors2[key];
+    if (!descriptor) continue;
+    if (!("value" in descriptor)) {
+      throw new DokusValidationError(`${label} must not contain accessors.`);
+    }
+    if (typeof key !== "string" || !allowedKeys.has(key)) {
+      throw new DokusValidationError(
+        `${label} contains unsupported field ${JSON.stringify(String(key))}.`
+      );
+    }
+    if (!descriptor.enumerable) {
+      throw new DokusValidationError(
+        `${label} field ${JSON.stringify(key)} must be enumerable.`
+      );
+    }
+  }
+  try {
+    for (const key of allowedKeys) {
+      if (!Object.hasOwn(value, key) && key in value) {
+        throw new DokusValidationError(
+          `${label} field ${JSON.stringify(key)} must be an own data property.`
+        );
+      }
+    }
+  } catch (error) {
+    if (error instanceof DokusValidationError) throw error;
+    throw new DokusValidationError(`${label} must be a plain data object.`);
+  }
+}
+function assertPlainObject(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new DokusValidationError(`${label} must be a plain data object.`);
+  }
+  let prototype;
+  try {
+    prototype = Object.getPrototypeOf(value);
+  } catch {
+    throw new DokusValidationError(`${label} must be a plain data object.`);
+  }
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new DokusValidationError(`${label} must be a plain data object.`);
+  }
+}
+function assertOptionalBoolean(value, label) {
+  if (value !== void 0 && typeof value !== "boolean") {
+    throw new DokusValidationError(`${label} must be a boolean.`);
+  }
+}
+function assertOptionalString(value, label) {
+  if (value !== void 0 && typeof value !== "string") {
+    throw new DokusValidationError(`${label} must be a string.`);
+  }
+}
+function assertOptionalEnum(value, allowed, label) {
+  if (value !== void 0 && !allowed.includes(value)) {
+    throw new DokusValidationError(
+      `${label} must be one of ${allowed.map((entry) => JSON.stringify(entry)).join(", ")}.`
+    );
+  }
+}
+function assertNonEmpty(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new DokusValidationError(`${label} must be a non-empty string.`);
+  }
+}
+function pathSegment(value, label) {
+  assertNonEmpty(value, label);
+  if (value.trim() !== value) {
+    throw new DokusValidationError(
+      `${label} must not contain surrounding whitespace.`
+    );
+  }
+  if (!UUID_PATTERN.test(value)) {
+    throw new DokusValidationError(`${label} must be a UUID.`);
+  }
+  return encodeURIComponent(value);
+}
+function assertOpaqueId(value, label) {
+  if (!OPAQUE_ID_PATTERN.test(value)) {
+    throw new DokusValidationError(
+      `${label} must be 8-128 characters using letters, numbers, dot, colon, underscore, or hyphen.`
+    );
+  }
+}
+function requireIdempotencyKey(options) {
+  const key = options?.idempotencyKey;
+  if (typeof key !== "string") {
+    throw new DokusValidationError(
+      "A validated idempotencyKey is required for this state-changing request."
+    );
+  }
+  assertOpaqueId(key, "idempotencyKey");
+  return key;
+}
+function assertPositiveFinite(value, label) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new DokusValidationError(
+      `${label} must be a positive finite number.`
+    );
+  }
+}
+function assertTimerMs(value, label) {
+  assertPositiveFinite(value, label);
+  if (value > 2147483647) {
+    throw new DokusValidationError(
+      `${label} exceeds the supported timer range.`
+    );
+  }
+}
+function assertPositiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new DokusValidationError(`${label} must be a positive safe integer.`);
+  }
+}
+function toEpochMs(value) {
+  if (value === null) return null;
+  const epochMs = value instanceof Date ? value.getTime() : value;
+  if (!Number.isSafeInteger(epochMs) || epochMs <= 0) {
+    throw new DokusValidationError(
+      "expireAt must be null, a valid Date, or a positive epoch-millisecond integer."
+    );
+  }
+  return epochMs;
+}
+function expireAtQuery(value) {
+  if (value === void 0) return void 0;
+  const epochMs = toEpochMs(value);
+  return epochMs === null ? "never" : String(epochMs);
+}
+
+// src/public-options.ts
+var REQUEST_KEYS = /* @__PURE__ */ new Set(["signal", "timeoutMs", "requestId"]);
+var WRITE_KEYS = /* @__PURE__ */ new Set([
+  "signal",
+  "timeoutMs",
+  "requestId",
+  "idempotencyKey"
+]);
+var RUN_GET_KEYS = /* @__PURE__ */ new Set(["signal", "timeoutMs", "requestId", "expireAt"]);
+var DOCUMENT_RUNS_KEYS = /* @__PURE__ */ new Set([
+  "signal",
+  "timeoutMs",
+  "requestId",
+  "limit"
+]);
+var WAIT_KEYS = /* @__PURE__ */ new Set([
+  "expireAt",
+  "signal",
+  "requestId",
+  "intervalMs",
+  "timeoutMs",
+  "requestTimeoutMs"
+]);
+var ROTATE_KEYS = /* @__PURE__ */ new Set([
+  "signal",
+  "timeoutMs",
+  "requestId",
+  "idempotencyKey",
+  "allowDownload",
+  "expiresIn"
+]);
+var EXPIRES_IN_KEYS = /* @__PURE__ */ new Set(["days"]);
+function assertSignal(value, label) {
+  if (value !== void 0 && !(value instanceof AbortSignal)) {
+    throw new DokusValidationError(`${label} must be an AbortSignal.`);
+  }
+}
+function assertRequestFields(options, label) {
+  assertSignal(options.signal, `${label}.signal`);
+  if (options.timeoutMs !== void 0) {
+    assertTimerMs(options.timeoutMs, `${label}.timeoutMs`);
+  }
+  if (options.requestId !== void 0) {
+    assertOpaqueId(options.requestId, `${label}.requestId`);
+  }
+}
+function assertRequestOptions(options, label = "request options") {
+  if (options === void 0) return;
+  assertExactDataObject(options, REQUEST_KEYS, label);
+  assertRequestFields(options, label);
+}
+function assertWriteOptions(options, label = "write options") {
+  if (options === void 0) {
+    throw new DokusValidationError(`${label} are required.`);
+  }
+  assertExactDataObject(options, WRITE_KEYS, label);
+  assertRequestFields(options, label);
+  requireIdempotencyKey(options);
+}
+function assertRunGetOptions(options) {
+  if (options === void 0) return;
+  assertExactDataObject(options, RUN_GET_KEYS, "runs.get options");
+  assertRequestFields(options, "runs.get options");
+  if (options.expireAt !== void 0) toEpochMs(options.expireAt);
+}
+function assertDocumentRunsOptions(options) {
+  if (options === void 0) return;
+  assertExactDataObject(
+    options,
+    DOCUMENT_RUNS_KEYS,
+    "workflows.documentRuns options"
+  );
+  assertRequestFields(options, "workflows.documentRuns options");
+  if (options.limit !== void 0) {
+    assertPositiveInteger(
+      options.limit,
+      "workflows.documentRuns options.limit"
+    );
+  }
+}
+function assertWaitOptions(options) {
+  if (options === void 0) return;
+  assertExactDataObject(options, WAIT_KEYS, "runs.wait options");
+  assertSignal(options.signal, "runs.wait options.signal");
+  if (options.requestId !== void 0) {
+    assertOpaqueId(options.requestId, "runs.wait options.requestId");
+  }
+  if (options.expireAt !== void 0) toEpochMs(options.expireAt);
+  if (options.intervalMs !== void 0) {
+    assertTimerMs(options.intervalMs, "runs.wait options.intervalMs");
+  }
+  if (options.timeoutMs !== void 0) {
+    assertTimerMs(options.timeoutMs, "runs.wait options.timeoutMs");
+  }
+  if (options.requestTimeoutMs !== void 0) {
+    assertTimerMs(
+      options.requestTimeoutMs,
+      "runs.wait options.requestTimeoutMs"
+    );
+  }
+}
+function assertRotateOptions(options) {
+  if (options === void 0) {
+    throw new DokusValidationError(
+      "runs.rotatePreviewLink options are required."
+    );
+  }
+  assertExactDataObject(options, ROTATE_KEYS, "runs.rotatePreviewLink options");
+  assertRequestFields(options, "runs.rotatePreviewLink options");
+  requireIdempotencyKey(options);
+  assertOptionalBoolean(
+    options.allowDownload,
+    "runs.rotatePreviewLink options.allowDownload"
+  );
+  if (options.expiresIn !== void 0 && options.expiresIn !== null) {
+    assertExactDataObject(
+      options.expiresIn,
+      EXPIRES_IN_KEYS,
+      "runs.rotatePreviewLink options.expiresIn"
+    );
+    assertPositiveInteger(
+      options.expiresIn.days,
+      "runs.rotatePreviewLink options.expiresIn.days"
+    );
+  }
+}
+
+// src/response-validation.ts
+var UUID_PATTERN2 = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+function invalid(requestId) {
+  throw new DokusProtocolError(requestId);
+}
+function record(value, requestId) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    invalid(requestId);
+  }
+  const result = /* @__PURE__ */ Object.create(null);
+  let keys;
+  try {
+    keys = Object.keys(value);
+  } catch {
+    invalid(requestId);
+  }
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable || !("value" in descriptor)) continue;
+    Object.defineProperty(result, key, {
+      enumerable: true,
+      value: descriptor.value
+    });
+  }
+  return result;
+}
+function string(value, requestId) {
+  return typeof value === "string" ? value : invalid(requestId);
+}
+function nullableString(value, requestId) {
+  return value === null ? null : string(value, requestId);
+}
+function uuid(value, requestId) {
+  return typeof value === "string" && UUID_PATTERN2.test(value) ? value : invalid(requestId);
+}
+function nullableUuid(value, requestId) {
+  return value === null ? null : uuid(value, requestId);
+}
+function nullableNumber(value, requestId) {
+  return value === null || typeof value === "number" && Number.isFinite(value) ? value : invalid(requestId);
+}
+function oneOf(value, allowed, requestId) {
+  return typeof value === "string" && allowed.includes(value) ? value : invalid(requestId);
+}
+function optionalString(source, key, requestId) {
+  return source[key] === void 0 ? void 0 : string(source[key], requestId);
+}
+function parsePreviewLink(value, requestId) {
+  if (value === null) return null;
+  const source = record(value, requestId);
+  if (typeof source.allowDownload !== "boolean") invalid(requestId);
+  return {
+    status: oneOf(source.status, ["issued", "revoked"], requestId),
+    createdAt: string(source.createdAt, requestId),
+    rotatedAt: nullableString(source.rotatedAt, requestId),
+    allowDownload: source.allowDownload,
+    expiresAt: nullableString(source.expiresAt, requestId)
+  };
+}
+function parseOutput(value, requestId) {
+  const source = record(value, requestId);
+  if (!Number.isSafeInteger(source.id) || source.id <= 0)
+    invalid(requestId);
+  return {
+    id: source.id,
+    fileType: oneOf(source.fileType, ["docx", "xlsx", "pdf"], requestId),
+    outputFileName: string(source.outputFileName, requestId),
+    status: oneOf(
+      source.status,
+      ["pending", "processing", "completed", "failed", "skipped"],
+      requestId
+    ),
+    error: nullableString(source.error, requestId),
+    size: nullableNumber(source.size, requestId),
+    pages: nullableNumber(source.pages, requestId),
+    completedAt: nullableString(source.completedAt, requestId),
+    downloadUrl: nullableString(source.downloadUrl, requestId),
+    previewUrl: nullableString(source.previewUrl, requestId),
+    previewLink: parsePreviewLink(source.previewLink, requestId)
+  };
+}
+function parseOutputs(value, requestId) {
+  if (!Array.isArray(value)) invalid(requestId);
+  return value.map((output) => parseOutput(output, requestId));
+}
+function parseRunResultResponse(value, requestId) {
+  const source = record(value, requestId);
+  return {
+    runId: uuid(source.runId, requestId),
+    workflowId: uuid(source.workflowId, requestId),
+    mode: oneOf(source.mode, ["sync", "async"], requestId),
+    status: oneOf(
+      source.status,
+      ["pending", "running", "completed", "failed", "cancelled"],
+      requestId
+    ),
+    startedAt: nullableString(source.startedAt, requestId),
+    completedAt: nullableString(source.completedAt, requestId),
+    error: nullableString(source.error, requestId),
+    createdAt: string(source.createdAt, requestId),
+    outputs: parseOutputs(source.outputs, requestId)
+  };
+}
+function parseDocumentRenderCompletedResponse(value, requestId) {
+  const run = parseRunResultResponse(value, requestId);
+  if (run.mode !== "sync") invalid(requestId);
+  const source = record(value, requestId);
+  return {
+    ...run,
+    documentId: uuid(source.documentId, requestId),
+    documentVersionId: uuid(source.documentVersionId, requestId),
+    planId: nullableUuid(source.planId, requestId),
+    mode: "sync"
+  };
+}
+function parseDocumentRenderStartedResponse(value, requestId) {
+  const source = record(value, requestId);
+  return {
+    documentId: uuid(source.documentId, requestId),
+    documentVersionId: uuid(source.documentVersionId, requestId),
+    planId: nullableUuid(source.planId, requestId),
+    runId: uuid(source.runId, requestId),
+    workflowId: uuid(source.workflowId, requestId),
+    status: oneOf(source.status, ["pending"], requestId)
+  };
+}
+function parseRunOutputsResponse(value, requestId) {
+  const source = record(value, requestId);
+  return {
+    runId: uuid(source.runId, requestId),
+    outputs: parseOutputs(source.outputs, requestId)
+  };
+}
+function parseOutputDownloadResponse(value, requestId) {
+  const source = record(value, requestId);
+  return {
+    url: string(source.url, requestId),
+    expiresAt: string(source.expiresAt, requestId)
+  };
+}
+function parsePreviewLinkRotatedResponse(value, requestId) {
+  const source = record(value, requestId);
+  const previewLink = parsePreviewLink(source.previewLink, requestId);
+  if (previewLink === null) invalid(requestId);
+  return {
+    previewUrl: string(source.previewUrl, requestId),
+    previewLink
+  };
+}
+function parseGenerateStartedResponse(value, requestId) {
+  const source = record(value, requestId);
+  return {
+    runId: uuid(source.runId, requestId),
+    temporalWorkflowId: string(source.temporalWorkflowId, requestId),
+    status: oneOf(source.status, ["started", "already_running"], requestId)
+  };
+}
+function parseGenerateAllResponse(value, requestId) {
+  if (!Array.isArray(value)) invalid(requestId);
+  return value.map((entry) => {
+    const source = record(entry, requestId);
+    const runId = source.runId === void 0 ? void 0 : uuid(source.runId, requestId);
+    const temporalWorkflowId = optionalString(
+      source,
+      "temporalWorkflowId",
+      requestId
+    );
+    const error = optionalString(source, "error", requestId);
+    return {
+      documentId: uuid(source.documentId, requestId),
+      status: oneOf(
+        source.status,
+        ["started", "already_running", "failed"],
+        requestId
+      ),
+      ...runId === void 0 ? {} : { runId },
+      ...temporalWorkflowId === void 0 ? {} : { temporalWorkflowId },
+      ...error === void 0 ? {} : { error }
+    };
+  });
+}
+function parseDocumentRunsResponse(value, requestId) {
+  if (!Array.isArray(value)) invalid(requestId);
+  return value.map((entry) => {
+    const source = record(entry, requestId);
+    if (!Number.isSafeInteger(source.outputCount) || source.outputCount < 0) {
+      invalid(requestId);
+    }
+    return {
+      id: uuid(source.id, requestId),
+      workflowId: uuid(source.workflowId, requestId),
+      status: oneOf(
+        source.status,
+        ["pending", "running", "completed", "failed", "cancelled"],
+        requestId
+      ),
+      startedAt: nullableString(source.startedAt, requestId),
+      completedAt: nullableString(source.completedAt, requestId),
+      error: nullableString(source.error, requestId),
+      triggeredByType: string(source.triggeredByType, requestId),
+      triggeredById: nullableString(source.triggeredById, requestId),
+      createdAt: string(source.createdAt, requestId),
+      outputCount: source.outputCount
+    };
+  });
+}
+
+// src/documents.ts
+var RENDER_INPUT_KEYS = /* @__PURE__ */ new Set([
+  "documentId",
+  "planId",
+  "contract",
+  "data",
+  "generatePdf",
+  "generateDocx",
+  "expireAt",
+  "version",
+  "versionId",
+  "mode"
+]);
+function transportWriteOptions(options) {
+  assertWriteOptions(options, "documents.render options");
+  return {
+    signal: options.signal,
+    timeoutMs: options.timeoutMs,
+    requestId: options.requestId,
+    idempotencyKey: options.idempotencyKey
+  };
+}
+function assertRenderInput(input) {
+  assertExactDataObject(input, RENDER_INPUT_KEYS, "documents.render input");
+  pathSegment(input.documentId, "documentId");
+  if (input.planId !== void 0) pathSegment(input.planId, "planId");
+  if (input.versionId !== void 0) pathSegment(input.versionId, "versionId");
+  assertOptionalEnum(input.version, ["latest", "draft"], "version");
+  assertOptionalEnum(input.mode, ["sync", "async"], "mode");
+  assertOptionalBoolean(input.generatePdf, "generatePdf");
+  assertOptionalBoolean(input.generateDocx, "generateDocx");
+  if (input.data !== void 0) assertPlainObject(input.data, "data");
+  if (input.contract !== void 0)
+    assertPlainObject(input.contract, "contract");
+  if (input.expireAt !== void 0) toEpochMs(input.expireAt);
+  if (input.version !== void 0 && input.versionId !== void 0) {
+    throw new DokusValidationError(
+      "Choose either version or versionId, not both."
+    );
+  }
+  if (input.planId !== void 0 && input.contract !== void 0) {
+    throw new DokusValidationError(
+      "Choose either planId or an inline contract, not both."
+    );
+  }
+  if (input.generatePdf === false && input.generateDocx !== true) {
+    throw new DokusValidationError(
+      "At least one output format must be enabled."
+    );
+  }
+}
+var Documents = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async render(input, options) {
+    assertRenderInput(input);
+    const mode = input.mode ?? "sync";
+    return this.transport.request(
+      "POST",
+      `/api/documents/${pathSegment(input.documentId, "documentId")}/run`,
+      {
+        ...transportWriteOptions(options),
+        parseResponse: (value, requestId) => mode === "async" ? parseDocumentRenderStartedResponse(value, requestId) : parseDocumentRenderCompletedResponse(value, requestId),
+        body: {
+          kind: "json",
+          value: {
+            data: input.data ?? {},
+            generatePdf: input.generatePdf ?? true,
+            mode,
+            ...input.planId !== void 0 ? { planId: input.planId } : {},
+            ...input.contract !== void 0 ? { contract: input.contract } : {},
+            ...input.version !== void 0 ? { version: input.version } : {},
+            ...input.versionId !== void 0 ? { versionId: input.versionId } : {},
+            ...input.generateDocx !== void 0 ? { generateDocx: input.generateDocx } : {},
+            ...input.expireAt !== void 0 ? { expireAt: toEpochMs(input.expireAt) } : {}
+          }
+        }
+      }
+    );
+  }
+};
+function createDocuments(transport) {
+  return new Documents(transport);
+}
+
+// src/runs.ts
+var TERMINAL = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+function capturePreviews(run, retained) {
+  for (const output of run.outputs) {
+    const current = retained.get(output.id) ?? {
+      previewUrl: null,
+      previewLink: null
+    };
+    current.previewUrl ??= output.previewUrl;
+    current.previewLink ??= output.previewLink;
+    retained.set(output.id, current);
+  }
+}
+function mergePreviews(run, retained) {
+  return {
+    ...run,
+    outputs: run.outputs.map((output) => {
+      const current = retained.get(output.id);
+      return current ? {
+        ...output,
+        previewUrl: current.previewUrl ?? output.previewUrl,
+        previewLink: current.previewLink ?? output.previewLink
+      } : output;
+    })
+  };
+}
+function transportRequestOptions(options = {}) {
+  return {
+    signal: options.signal,
+    timeoutMs: options.timeoutMs,
+    requestId: options.requestId
+  };
+}
+function pollSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DokusAbortError());
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new DokusAbortError());
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function outputPath(runId, outputId) {
+  assertPositiveInteger(outputId, "outputId");
+  return `/api/runs/${pathSegment(runId, "runId")}/outputs/${outputId}`;
+}
+function createRuns(transport) {
+  const get = async (runId, options = {}) => {
+    assertRunGetOptions(options);
+    return transport.request(
+      "GET",
+      `/api/runs/${pathSegment(runId, "runId")}`,
+      {
+        ...transportRequestOptions(options),
+        parseResponse: parseRunResultResponse,
+        query: { expireAt: expireAtQuery(options.expireAt) }
+      }
+    );
+  };
+  return {
+    get,
+    outputs: async (runId, options) => {
+      assertRequestOptions(options, "runs.outputs options");
+      return transport.request(
+        "GET",
+        `/api/runs/${pathSegment(runId, "runId")}/outputs`,
+        {
+          ...transportRequestOptions(options),
+          parseResponse: parseRunOutputsResponse
+        }
+      );
+    },
+    outputDownload: async (runId, outputId, options) => {
+      assertRequestOptions(options, "runs.outputDownload options");
+      return transport.request(
+        "GET",
+        `${outputPath(runId, outputId)}/download`,
+        {
+          ...transportRequestOptions(options),
+          parseResponse: parseOutputDownloadResponse
+        }
+      );
+    },
+    rotatePreviewLink: async (runId, outputId, options) => {
+      assertRotateOptions(options);
+      const value = {
+        ...options.allowDownload !== void 0 ? { allowDownload: options.allowDownload } : {},
+        ...options.expiresIn !== void 0 ? { expiresIn: options.expiresIn } : {}
+      };
+      return transport.request(
+        "POST",
+        `${outputPath(runId, outputId)}/preview-link/rotate`,
+        {
+          ...transportRequestOptions(options),
+          idempotencyKey: options.idempotencyKey,
+          parseResponse: parsePreviewLinkRotatedResponse,
+          ...Object.keys(value).length ? { body: { kind: "json", value } } : {}
+        }
+      );
+    },
+    revokePreviewLink: async (runId, outputId, options) => {
+      assertWriteOptions(options, "runs.revokePreviewLink options");
+      await transport.request(
+        "DELETE",
+        `${outputPath(runId, outputId)}/preview-link`,
+        {
+          ...transportRequestOptions(options),
+          idempotencyKey: options.idempotencyKey,
+          responseKind: "void"
+        }
+      );
+    },
+    delete: async (runId, options) => {
+      assertWriteOptions(options, "runs.delete options");
+      await transport.request(
+        "DELETE",
+        `/api/runs/${pathSegment(runId, "runId")}`,
+        {
+          ...transportRequestOptions(options),
+          idempotencyKey: options.idempotencyKey,
+          responseKind: "void"
+        }
+      );
+    },
+    wait: async (runId, options = {}) => {
+      assertWaitOptions(options);
+      pathSegment(runId, "runId");
+      const intervalMs = options.intervalMs ?? 2e3;
+      const timeoutMs = options.timeoutMs ?? 12e4;
+      if (options.signal?.aborted) throw new DokusAbortError(options.requestId);
+      const deadline = Date.now() + timeoutMs;
+      const retained = /* @__PURE__ */ new Map();
+      for (; ; ) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+          throw new DokusWaitTimeoutError(timeoutMs, "unknown");
+        }
+        const run = await get(runId, {
+          expireAt: options.expireAt,
+          signal: options.signal,
+          requestId: options.requestId,
+          timeoutMs: Math.min(options.requestTimeoutMs ?? remaining, remaining)
+        });
+        capturePreviews(run, retained);
+        if (TERMINAL.has(run.status)) return mergePreviews(run, retained);
+        if (Date.now() + intervalMs > deadline) {
+          throw new DokusWaitTimeoutError(timeoutMs, run.status);
+        }
+        await pollSleep(intervalMs, options.signal);
+      }
+    }
+  };
+}
+
+// src/transport/base-url.ts
+var DOKUS_API_BASE_URL = "https://api.dokus.pro";
+function normalizeBaseUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new DokusValidationError("baseUrl must be a valid absolute URL.");
+  }
+  if (url.username || url.password) {
+    throw new DokusValidationError("baseUrl must not contain credentials.");
+  }
+  if (url.search || url.hash) {
+    throw new DokusValidationError(
+      "baseUrl must not contain a query or fragment."
+    );
+  }
+  const hostname = url.hostname.toLowerCase();
+  const loopback = hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname === "[::1]";
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+    throw new DokusValidationError(
+      "baseUrl must use HTTPS; HTTP is allowed only for a loopback host."
+    );
+  }
+  return url.toString().replace(/\/+$/, "");
+}
+function buildRequestUrl(baseUrl, path, query = {}) {
+  if (!path.startsWith("/") || path.includes("?") || path.includes("#")) {
+    throw new DokusValidationError("The request path is invalid.");
+  }
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) search.set(key, String(value));
+  }
+  const serialized = search.toString();
+  return `${baseUrl}${path}${serialized ? `?${serialized}` : ""}`;
+}
+
+// src/transport/json-body.ts
+var MAX_DEPTH = 32;
+var MAX_NODES = 1e5;
+var MAX_UTF8_BYTES = 1024 * 1024;
+function invalid2(reason) {
+  throw new DokusValidationError(`The request body ${reason}.`);
+}
+function descriptors(value) {
+  try {
+    return Object.getOwnPropertyDescriptors(value);
+  } catch {
+    return invalid2("must contain only inspectable data properties");
+  }
+}
+function prototypeOf(value) {
+  try {
+    return Object.getPrototypeOf(value);
+  } catch {
+    return invalid2("must contain only inspectable data values");
+  }
+}
+function descriptorAt(source, key) {
+  return Object.getOwnPropertyDescriptor(source, key)?.value;
+}
+function enter(value, state, depth) {
+  if (depth > MAX_DEPTH) invalid2("exceeds the maximum nesting depth");
+  if (state.active.has(value)) invalid2("must not contain cycles");
+  state.active.add(value);
+}
+function count(state) {
+  state.nodes += 1;
+  if (state.nodes > MAX_NODES) invalid2("exceeds the maximum node count");
+}
+function cloneArray(value, state, depth) {
+  if (prototypeOf(value) !== Array.prototype) {
+    return invalid2("must not contain array subclasses");
+  }
+  if (value.length > MAX_NODES) invalid2("exceeds the maximum node count");
+  enter(value, state, depth);
+  try {
+    const source = descriptors(value);
+    const keys = Reflect.ownKeys(source);
+    if (keys.length !== value.length + 1 || !keys.includes("length")) {
+      return invalid2("must not contain sparse or decorated arrays");
+    }
+    const result = new Array(value.length);
+    for (let index = 0; index < value.length; index += 1) {
+      const descriptor = descriptorAt(source, String(index));
+      if (!descriptor?.enumerable || !("value" in descriptor)) {
+        return invalid2("must not contain sparse or accessor-bearing arrays");
+      }
+      result[index] = cloneJson(descriptor.value, state, depth + 1);
+    }
+    return result;
+  } finally {
+    state.active.delete(value);
+  }
+}
+function cloneObject(value, state, depth) {
+  const prototype = prototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    return invalid2("must contain only plain or null-prototype objects");
+  }
+  enter(value, state, depth);
+  try {
+    const source = descriptors(value);
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const key of Reflect.ownKeys(source)) {
+      if (typeof key !== "string") {
+        return invalid2("must not contain symbol-keyed properties");
+      }
+      const descriptor = descriptorAt(source, key);
+      if (!descriptor?.enumerable || !("value" in descriptor)) {
+        return invalid2("must contain only enumerable data properties");
+      }
+      Object.defineProperty(result, key, {
+        enumerable: true,
+        value: cloneJson(descriptor.value, state, depth + 1)
+      });
+    }
+    return result;
+  } finally {
+    state.active.delete(value);
+  }
+}
+function cloneJson(value, state, depth) {
+  if (depth > MAX_DEPTH) invalid2("exceeds the maximum nesting depth");
+  count(state);
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : invalid2("must contain only finite numbers");
+  }
+  if (Array.isArray(value)) return cloneArray(value, state, depth);
+  if (typeof value === "object") return cloneObject(value, state, depth);
+  return invalid2("must contain only JSON values");
+}
+function encodeJsonRequestBody(value) {
+  const clone = cloneJson(value, { nodes: 0, active: /* @__PURE__ */ new WeakSet() }, 0);
+  const encoded = JSON.stringify(clone);
+  if (new TextEncoder().encode(encoded).byteLength > MAX_UTF8_BYTES) {
+    invalid2("exceeds the maximum UTF-8 byte size");
+  }
+  return encoded;
+}
+
+// src/transport/retry.ts
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([
+  408,
+  429,
+  502,
+  503,
+  504
+]);
+function parseRetryAfter(value, now = Date.now()) {
+  if (value === null) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(0, date - now) : void 0;
+}
+function retryDelayMs(attempt, retryAfterMs, maxDelayMs) {
+  if (retryAfterMs !== void 0) return Math.min(retryAfterMs, maxDelayMs);
+  const ceiling = Math.min(250 * 2 ** (attempt - 1), maxDelayMs);
+  return Math.round(ceiling * (0.5 + Math.random() * 0.5));
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/transport/response.ts
+var JSON_LIMIT_BYTES = 1024 * 1024;
+var BINARY_LIMIT_BYTES = 64 * 1024 * 1024;
+var SENSITIVE_KEYS = /(?:api[-_]?key|authorization|cookie|password|secret|token|headers?|body)/i;
+function ownDataRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const result = /* @__PURE__ */ Object.create(null);
+  let keys;
+  try {
+    keys = Object.keys(value);
+  } catch {
+    return null;
+  }
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable || !("value" in descriptor)) continue;
+    Object.defineProperty(result, key, {
+      enumerable: true,
+      value: descriptor.value
+    });
+  }
+  return result;
+}
+function header(response, name) {
+  return typeof response.headers?.get === "function" ? response.headers.get(name) : null;
+}
+function responseRequestId(response, fallback, apiKey) {
+  const value = header(response, "x-request-id");
+  return value && /^[A-Za-z0-9._:-]{8,128}$/.test(value) && value !== apiKey ? value : fallback;
+}
+async function readBounded(response, limitBytes, requestId) {
+  const declared = Number(header(response, "content-length"));
+  if (Number.isFinite(declared) && declared > limitBytes) {
+    throw new DokusResponseTooLargeError(limitBytes, requestId);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    const bytes2 = new Uint8Array(await response.arrayBuffer());
+    if (bytes2.byteLength > limitBytes) {
+      throw new DokusResponseTooLargeError(limitBytes, requestId);
+    }
+    return bytes2;
+  }
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > limitBytes) {
+      await reader.cancel().catch(() => void 0);
+      throw new DokusResponseTooLargeError(limitBytes, requestId);
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+function parseJson(bytes) {
+  if (bytes.byteLength === 0) return null;
+  try {
+    return JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    return null;
+  }
+}
+function redactText(value, apiKey) {
+  return value.includes(apiKey) ? value.split(apiKey).join("[REDACTED]") : value;
+}
+function ownEnumerableDataEntries(value) {
+  let keys;
+  try {
+    keys = Object.keys(value);
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const key of keys.slice(0, 30)) {
+    let descriptor;
+    try {
+      descriptor = Object.getOwnPropertyDescriptor(value, key);
+    } catch {
+      continue;
+    }
+    if (!descriptor?.enumerable || !("value" in descriptor)) continue;
+    entries.push([key, descriptor.value]);
+  }
+  return entries;
+}
+function safePropertyName(key, apiKey) {
+  return SENSITIVE_KEYS.test(key) || key.includes(apiKey) ? "[REDACTED]" : redactText(key.slice(0, 256), apiKey);
+}
+function safeDetails(value, apiKey, depth = 0) {
+  if (depth > 4) return "[TRUNCATED]";
+  if (typeof value === "string") {
+    return redactText(value.slice(0, 2048), apiKey);
+  }
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const result = [];
+    for (let index = 0; index < Math.min(value.length, 20); index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (descriptor?.enumerable && "value" in descriptor) {
+        result.push(safeDetails(descriptor.value, apiKey, depth + 1));
+      }
+    }
+    return result;
+  }
+  if (typeof value === "object") {
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const [key, item] of ownEnumerableDataEntries(value)) {
+      const outputKey = safePropertyName(key, apiKey);
+      Object.defineProperty(result, outputKey, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value: outputKey === "[REDACTED]" ? "[REDACTED]" : safeDetails(item, apiKey, depth + 1)
+      });
+    }
+    return result;
+  }
+  return void 0;
+}
+function errorFromEnvelope(response, envelope, requestId, apiKey) {
+  const error = ownDataRecord(envelope?.error);
+  const code = typeof error?.code === "string" ? redactText(error.code.slice(0, 256), apiKey) : void 0;
+  const retryAfterMs = parseRetryAfter(header(response, "retry-after"));
+  if (typeof error?.message === "string" && error.message.length > 0) {
+    return new DokusApiError(
+      redactText(error.message.slice(0, 4096), apiKey),
+      response.status,
+      requestId,
+      code,
+      safeDetails(error.details, apiKey),
+      retryAfterMs
+    );
+  }
+  const issues = Array.isArray(error?.issues) ? error.issues : [];
+  const messages = issues.slice(0, 3).map((issue) => ownDataRecord(issue)?.message).filter((message2) => typeof message2 === "string").map((message2) => redactText(message2.slice(0, 1024), apiKey));
+  const message = messages.length ? `Dokus API request rejected (${response.status}): ${messages.join("; ")}` : `Dokus API request failed (${response.status})`;
+  return new DokusApiError(
+    message,
+    response.status,
+    requestId,
+    code,
+    issues.length ? safeDetails({ issues }, apiKey) : void 0,
+    retryAfterMs
+  );
+}
+async function decodeResponse(response, kind, fallbackRequestId, apiKey, parseResponse) {
+  const requestId = responseRequestId(response, fallbackRequestId, apiKey);
+  if (response.status === 204) {
+    if (kind !== "void") throw new DokusProtocolError(requestId);
+    return void 0;
+  }
+  if (kind === "binary" && response.ok) {
+    return await readBounded(response, BINARY_LIMIT_BYTES, requestId);
+  }
+  const bytes = await readBounded(response, JSON_LIMIT_BYTES, requestId);
+  const parsed = parseJson(bytes);
+  const envelope = ownDataRecord(parsed);
+  if (!response.ok) {
+    throw errorFromEnvelope(response, envelope, requestId, apiKey);
+  }
+  if (kind === "void") return void 0;
+  if (envelope?.success !== true || !Object.hasOwn(envelope, "data")) {
+    throw new DokusProtocolError(requestId);
+  }
+  return parseResponse ? parseResponse(envelope.data, requestId) : envelope.data;
+}
+
+// src/transport/transport.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_MAX_RETRY_DELAY_MS = 3e4;
+var CLIENT_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "apiKey",
+  "baseUrl",
+  "fetch",
+  "timeoutMs",
+  "retry"
+]);
+var RETRY_OPTION_KEYS = /* @__PURE__ */ new Set(["maxAttempts", "maxDelayMs"]);
+function isDeniedRuntime() {
+  const scope = globalThis;
+  return typeof scope.window !== "undefined" || typeof scope.document !== "undefined" || typeof scope.importScripts === "function" || /WorkerGlobalScope$/.test(scope.constructor?.name ?? "");
+}
+function deadlineSignal(caller, timeoutMs) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const onAbort = () => controller.abort();
+  if (caller?.aborted) controller.abort();
+  else caller?.addEventListener("abort", onAbort, { once: true });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  return {
+    signal: controller.signal,
+    didTimeout: () => timedOut,
+    dispose: () => {
+      clearTimeout(timer);
+      caller?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+function encodeBody(body) {
+  if (!body) return {};
+  if (body.kind === "multipart") return { body: body.value };
+  if (body.kind === "binary") {
+    return { body: body.value, contentType: body.contentType };
+  }
+  return {
+    body: encodeJsonRequestBody(body.value),
+    contentType: "application/json"
+  };
+}
+function validateConfig(options) {
+  assertExactDataObject(
+    options,
+    CLIENT_OPTION_KEYS,
+    "createDokusClient options"
+  );
+  if (options.baseUrl !== void 0 && typeof options.baseUrl !== "string") {
+    throw new DokusValidationError("baseUrl must be a string.");
+  }
+  if (options.fetch !== void 0 && typeof options.fetch !== "function") {
+    throw new DokusValidationError("fetch must be a function.");
+  }
+  if (options.retry !== void 0 && options.retry !== false) {
+    assertExactDataObject(options.retry, RETRY_OPTION_KEYS, "retry options");
+  }
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  assertTimerMs(timeoutMs, "timeoutMs");
+  const maxAttempts = options.retry === false ? 1 : options.retry?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  const maxDelayMs = options.retry === false ? 0 : options.retry?.maxDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+  assertPositiveInteger(maxAttempts, "retry.maxAttempts");
+  if (maxAttempts > 10) {
+    throw new DokusValidationError("retry.maxAttempts must not exceed 10.");
+  }
+  if (options.retry !== false) assertTimerMs(maxDelayMs, "retry.maxDelayMs");
+  return { timeoutMs, maxAttempts, maxDelayMs };
+}
+function createTransport(options) {
+  const config = validateConfig(options);
+  if (typeof options.apiKey !== "string" || options.apiKey.trim().length === 0) {
+    throw new DokusValidationError("createDokusClient requires an apiKey.");
+  }
+  if (isDeniedRuntime()) {
+    throw new DokusValidationError(
+      "createDokusClient is server-only; keep Dokus API keys out of browsers and web workers."
+    );
+  }
+  const apiKey = options.apiKey;
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new DokusValidationError("No fetch implementation is available.");
+  }
+  const baseUrl = normalizeBaseUrl(options.baseUrl ?? DOKUS_API_BASE_URL);
+  return {
+    request: async (method, path, init = {}) => {
+      const requestId = init.requestId ?? randomUUID();
+      assertOpaqueId(requestId, "requestId");
+      if (requestId === apiKey) {
+        throw new DokusValidationError(
+          "requestId must be independent from the apiKey."
+        );
+      }
+      if (init.idempotencyKey !== void 0) {
+        assertOpaqueId(init.idempotencyKey, "idempotencyKey");
+      }
+      const timeoutMs = init.timeoutMs ?? config.timeoutMs;
+      assertTimerMs(timeoutMs, "timeoutMs");
+      const url = buildRequestUrl(baseUrl, path, init.query);
+      const encoded = encodeBody(init.body);
+      const headers = {
+        accept: init.responseKind === "binary" ? "application/octet-stream" : "application/json",
+        "x-api-key": apiKey,
+        "x-request-id": requestId,
+        ...encoded.contentType ? { "content-type": encoded.contentType } : {},
+        ...init.idempotencyKey ? { "idempotency-key": init.idempotencyKey } : {}
+      };
+      const attempts = method === "GET" ? config.maxAttempts : 1;
+      const deadline = deadlineSignal(init.signal, timeoutMs);
+      try {
+        if (deadline.signal.aborted) throw new DokusAbortError(requestId);
+        for (let attempt = 1; attempt <= attempts; attempt += 1) {
+          let response;
+          try {
+            response = await fetchImpl(url, {
+              method,
+              headers,
+              ...encoded.body !== void 0 ? { body: encoded.body } : {},
+              signal: deadline.signal,
+              redirect: "error"
+            });
+          } catch {
+            if (deadline.signal.aborted) {
+              throw deadline.didTimeout() ? new DokusTimeoutError(timeoutMs, requestId) : new DokusAbortError(requestId);
+            }
+            if (attempt === attempts) throw new DokusConnectionError(requestId);
+            await sleep(
+              retryDelayMs(attempt, void 0, config.maxDelayMs),
+              deadline.signal
+            );
+            continue;
+          }
+          if (RETRYABLE_STATUSES.has(response.status) && attempt < attempts) {
+            const retryAfter = parseRetryAfter(
+              response.headers.get("retry-after")
+            );
+            await response.body?.cancel().catch(() => void 0);
+            await sleep(
+              retryDelayMs(attempt, retryAfter, config.maxDelayMs),
+              deadline.signal
+            );
+            continue;
+          }
+          return await decodeResponse(
+            response,
+            init.responseKind ?? "json",
+            requestId,
+            apiKey,
+            init.parseResponse
+          );
+        }
+        throw new DokusConnectionError(requestId);
+      } catch (error) {
+        if (error instanceof DokusTimeoutError || error instanceof DokusAbortError)
+          throw error;
+        if (deadline.signal.aborted) {
+          throw deadline.didTimeout() ? new DokusTimeoutError(timeoutMs, requestId) : new DokusAbortError(requestId);
+        }
+        throw error;
+      } finally {
+        deadline.dispose();
+      }
+    }
+  };
+}
+
+// src/workflows.ts
+var GENERATE_INPUT_KEYS = /* @__PURE__ */ new Set([
+  "documentId",
+  "data",
+  "versionId",
+  "versionSpec",
+  "outputFileNameOverride",
+  "generatePdf",
+  "generateDocx"
+]);
+var GENERATE_ALL_INPUT_KEYS = /* @__PURE__ */ new Set([
+  "data",
+  "versionSpec",
+  "generatePdf",
+  "generateDocx",
+  "documentIds"
+]);
+function requestOptions(options = {}) {
+  return {
+    signal: options.signal,
+    timeoutMs: options.timeoutMs,
+    requestId: options.requestId
+  };
+}
+function writeOptions(options, label) {
+  assertWriteOptions(options, label);
+  return {
+    ...requestOptions(options),
+    idempotencyKey: options.idempotencyKey
+  };
+}
+function assertGenerateInput(input) {
+  assertExactDataObject(input, GENERATE_INPUT_KEYS, "workflows.generate input");
+  pathSegment(input.documentId, "documentId");
+  if (input.versionId !== void 0) pathSegment(input.versionId, "versionId");
+  assertOptionalEnum(input.versionSpec, ["latest", "draft"], "versionSpec");
+  assertOptionalString(input.outputFileNameOverride, "outputFileNameOverride");
+  assertOptionalBoolean(input.generatePdf, "generatePdf");
+  assertOptionalBoolean(input.generateDocx, "generateDocx");
+  if (input.data !== void 0) assertPlainObject(input.data, "data");
+  if (input.versionSpec !== void 0 && input.versionId !== void 0) {
+    throw new DokusValidationError(
+      "Choose either versionSpec or versionId, not both."
+    );
+  }
+  if (input.generatePdf === false && input.generateDocx !== true) {
+    throw new DokusValidationError(
+      "At least one output format must be enabled."
+    );
+  }
+}
+function assertGenerateAllInput(input) {
+  if (input === void 0) return;
+  assertExactDataObject(
+    input,
+    GENERATE_ALL_INPUT_KEYS,
+    "workflows.generateAll input"
+  );
+  assertOptionalEnum(input.versionSpec, ["latest", "draft"], "versionSpec");
+  assertOptionalBoolean(input.generatePdf, "generatePdf");
+  assertOptionalBoolean(input.generateDocx, "generateDocx");
+  if (input.data !== void 0) assertPlainObject(input.data, "data");
+  if (input.documentIds !== void 0) {
+    if (!Array.isArray(input.documentIds)) {
+      throw new DokusValidationError("documentIds must be an array.");
+    }
+    encodeJsonRequestBody(input.documentIds);
+    if (input.documentIds.length === 0) {
+      throw new DokusValidationError("documentIds must not be empty.");
+    }
+    for (const [index, documentId] of input.documentIds.entries()) {
+      pathSegment(documentId, `documentIds[${index}]`);
+    }
+  }
+}
+function generateBody(input, mode) {
+  return {
+    documentId: input.documentId,
+    data: input.data ?? {},
+    generatePdf: input.generatePdf ?? true,
+    mode,
+    ...input.versionId !== void 0 ? { versionId: input.versionId } : {},
+    ...input.versionSpec !== void 0 ? { versionSpec: input.versionSpec } : {},
+    ...input.outputFileNameOverride !== void 0 ? { outputFileNameOverride: input.outputFileNameOverride } : {},
+    ...input.generateDocx !== void 0 ? { generateDocx: input.generateDocx } : {}
+  };
+}
+function createWorkflows(transport) {
+  const generatePath = (workflowId) => `/api/workflows/${pathSegment(workflowId, "workflowId")}/generate`;
+  const generationRequest = (workflowId, input, options, mode) => {
+    assertGenerateInput(input);
+    return {
+      path: generatePath(workflowId),
+      init: {
+        ...writeOptions(options, "workflows.generate options"),
+        body: { kind: "json", value: generateBody(input, mode) }
+      }
+    };
+  };
+  return {
+    generate: async (workflowId, input, options) => {
+      const request = generationRequest(workflowId, input, options, "async");
+      return transport.request("POST", request.path, {
+        ...request.init,
+        parseResponse: parseGenerateStartedResponse
+      });
+    },
+    generateSync: async (workflowId, input, options) => {
+      const request = generationRequest(workflowId, input, options, "sync");
+      return transport.request("POST", request.path, {
+        ...request.init,
+        parseResponse: parseRunResultResponse
+      });
+    },
+    generateAll: async (workflowId, input, options) => {
+      assertGenerateAllInput(input);
+      return transport.request(
+        "POST",
+        `/api/workflows/${pathSegment(workflowId, "workflowId")}/generate-all`,
+        {
+          ...writeOptions(options, "workflows.generateAll options"),
+          parseResponse: parseGenerateAllResponse,
+          body: { kind: "json", value: input ?? {} }
+        }
+      );
+    },
+    documentRuns: async (workflowId, documentId, options) => {
+      assertDocumentRunsOptions(options);
+      return transport.request(
+        "GET",
+        `/api/workflows/${pathSegment(workflowId, "workflowId")}/documents/${pathSegment(documentId, "documentId")}/runs`,
+        {
+          ...requestOptions(options),
+          parseResponse: parseDocumentRunsResponse,
+          query: { limit: options?.limit }
+        }
+      );
+    }
+  };
+}
+
+// src/index.ts
+function createDokusClient(options) {
+  const transport = createTransport(options);
+  return {
+    documents: createDocuments(transport),
+    runs: createRuns(transport),
+    workflows: createWorkflows(transport)
+  };
+}
+
+export { DOKUS_API_BASE_URL, createDokusClient };