@dalea/sdk 0.1.2

package/dist/index.js

@@ -0,0 +1,1227 @@
+// src/config.ts
+var SDK_VERSION = "0.1.2" ;
+function detectRuntime() {
+  if (typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined") {
+    return "browser";
+  }
+  if (typeof globalThis.EdgeRuntime !== "undefined") return "edge";
+  return "node";
+}
+function resolveConfig(cfg) {
+  const fetchImpl = cfg.fetch ?? globalThis.fetch?.bind(globalThis);
+  if (!fetchImpl) {
+    throw new Error("DaleaClient: no global fetch available; provide config.fetch");
+  }
+  return {
+    baseUrl: cfg.baseUrl ?? "",
+    maxRetries: cfg.maxRetries ?? 2,
+    retryWrites: cfg.retryWrites ?? true,
+    retryBaseDelayMs: cfg.retryBaseDelayMs ?? 500,
+    maxRetryDelayMs: cfg.maxRetryDelayMs ?? 2e4,
+    timeoutMs: cfg.timeoutMs ?? 3e4,
+    fetch: fetchImpl,
+    interceptors: cfg.interceptors ?? {},
+    runtime: detectRuntime(),
+    apiVersion: cfg.apiVersion
+  };
+}
+
+// src/core/errors.ts
+var PERMISSION_DENIED_CODES = [
+  "PERMISSION_DENIED",
+  "APP_PERMISSION_DENIED",
+  "API_KEY_PERMISSION_DENIED"
+];
+var DaleaError = class extends Error {
+  constructor(status, code, message, data, isMutation = false) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.data = data;
+    this.isMutation = isMutation;
+    this.name = new.target.name;
+  }
+};
+var DaleaAuthError = class extends DaleaError {
+};
+var DaleaBannedError = class extends DaleaError {
+};
+var DaleaPermissionError = class extends DaleaError {
+};
+var DaleaArchivedError = class extends DaleaError {
+};
+var DaleaNotFoundError = class extends DaleaError {
+};
+var DaleaConflictError = class extends DaleaError {
+};
+var DaleaValidationError = class extends DaleaError {
+};
+var DaleaQuotaError = class extends DaleaError {
+};
+var DaleaServerError = class extends DaleaError {
+};
+var DaleaNetworkError = class extends DaleaError {
+};
+var DaleaRateLimitError = class extends DaleaError {
+  // 429
+  retryAfterSeconds;
+  constructor(status, code, message, data, isMutation = false, retryAfterSeconds) {
+    super(status, code, message, data, isMutation);
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+};
+function mapError(status, code, message, data, isMutation) {
+  switch (status) {
+    case 401:
+      return new DaleaAuthError(status, code, message, data, isMutation);
+    case 403:
+      if (code === "USER_BANNED") return new DaleaBannedError(status, code, message, data, isMutation);
+      return new DaleaPermissionError(status, code, message, data, isMutation);
+    case 404:
+      return new DaleaNotFoundError(status, code, message, data, isMutation);
+    case 409:
+      return new DaleaConflictError(status, code, message, data, isMutation);
+    case 429: {
+      const ra = typeof data.retry_after_seconds === "number" ? data.retry_after_seconds : void 0;
+      return new DaleaRateLimitError(status, code, message, data, isMutation, ra);
+    }
+    case 507:
+      return new DaleaQuotaError(status, code, message, data, isMutation);
+    case 400:
+      if (code === "ENTITY_ARCHIVED") return new DaleaArchivedError(status, code, message, data, isMutation);
+      return new DaleaValidationError(status, code, message, data, isMutation);
+    case 422:
+      return new DaleaValidationError(status, code, message, data, isMutation);
+    default:
+      if (status >= 500) return new DaleaServerError(status, code, message, data, isMutation);
+      return new DaleaError(status, code, message, data, isMutation);
+  }
+}
+
+// src/core/retry.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 503]);
+function shouldAttemptRetry(status, method, attempt, policy) {
+  return RETRYABLE_STATUS.has(status) && attempt < policy.maxRetries && (method === "GET" || policy.retryWrites);
+}
+function computeRetryDelay(attempt, retryAfterHeader, retryAfterBody, policy, random = Math.random) {
+  const serverHintMs = parseRetryAfterMs(retryAfterHeader, retryAfterBody);
+  if (serverHintMs !== null && serverHintMs > policy.maxRetryDelayMs) return null;
+  const expBase = Math.min(policy.maxRetryDelayMs, policy.retryBaseDelayMs * 2 ** attempt);
+  if (serverHintMs !== null) {
+    return Math.min(policy.maxRetryDelayMs, serverHintMs + random() * Math.min(expBase, 1e3));
+  }
+  return random() * expBase;
+}
+function parseRetryAfterMs(header, body) {
+  const parsed = header ? parseInt(header, 10) : NaN;
+  if (!Number.isNaN(parsed)) return Math.max(0, parsed) * 1e3;
+  if (typeof body === "number" && Number.isFinite(body)) return Math.max(0, body) * 1e3;
+  return null;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve();
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/core/transport.ts
+var Transport = class {
+  constructor(cfg, credential, workspace) {
+    this.cfg = cfg;
+    this.credential = credential;
+    this.workspace = workspace;
+  }
+  inflight = /* @__PURE__ */ new Map();
+  request(method, path, opts = {}) {
+    const url = this.cfg.baseUrl + path + buildQuery(opts.query);
+    if (method === "GET" && !opts.skipDedup && !opts.rawResponse) {
+      const cred = opts.credential ?? this.credential;
+      const ws = opts.workspace ?? this.workspace.get() ?? "";
+      const dedupKey = `${cred.key?.() ?? "anon"}:ws-${ws}:${url}`;
+      const existing = this.inflight.get(dedupKey);
+      if (existing) return existing;
+      const p = this.execute(method, url, opts);
+      this.inflight.set(dedupKey, p);
+      const cleanup = () => this.inflight.delete(dedupKey);
+      p.then(cleanup, cleanup);
+      return p;
+    }
+    return this.execute(method, url, opts);
+  }
+  async execute(method, url, opts, attempt = 0, refreshed = false) {
+    const raw = isRawBody(opts.body);
+    const headers = new Headers({
+      ...raw ? {} : { "Content-Type": "application/json" },
+      ...opts.headers
+    });
+    if (opts.body instanceof FormData) headers.delete("Content-Type");
+    const body = opts.auditReason !== void 0 && !raw && method !== "GET" ? {
+      ...opts.body && typeof opts.body === "object" ? opts.body : {},
+      reason: opts.auditReason
+    } : opts.body;
+    const ctx = {
+      url,
+      method,
+      headers,
+      runtime: this.cfg.runtime,
+      includeCookies: false
+    };
+    const credential = opts.credential ?? this.credential;
+    await credential.apply(ctx);
+    this.workspace.apply(ctx, opts.workspace);
+    if (this.cfg.runtime === "node") {
+      headers.set("User-Agent", `dalea-sdk-ts/${SDK_VERSION}`);
+    }
+    if (this.cfg.apiVersion) headers.set("X-Dalea-Version", this.cfg.apiVersion);
+    this.cfg.interceptors.onRequest?.({ url, method, headers });
+    const signal = opts.signal ?? (opts.stream || !this.cfg.timeoutMs ? void 0 : AbortSignal.timeout(this.cfg.timeoutMs));
+    let res;
+    try {
+      res = await this.cfg.fetch(url, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : raw ? body : JSON.stringify(body),
+        credentials: ctx.includeCookies ? "include" : "same-origin",
+        signal
+      });
+    } catch (e) {
+      const err = new DaleaNetworkError(0, "NETWORK", e.message, void 0, method !== "GET");
+      this.cfg.interceptors.onError?.(err);
+      throw err;
+    }
+    credential.onResponse?.(res);
+    this.cfg.interceptors.onResponse?.(res);
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      const errObj = data.error;
+      const message = typeof data.message === "string" && data.message || (typeof errObj === "string" ? errObj : errObj?.message) || "An error occurred";
+      const code = typeof data.code === "string" && data.code || (typeof errObj === "object" ? errObj?.code : void 0) || "UNKNOWN_ERROR";
+      if (res.status === 401 && !refreshed && credential.refresh) {
+        const ok = await credential.refresh();
+        if (ok) return this.execute(method, url, opts, attempt, true);
+      }
+      if (shouldAttemptRetry(res.status, method, attempt, this.cfg)) {
+        const delayMs = computeRetryDelay(
+          attempt,
+          res.headers.get("Retry-After"),
+          data.retry_after_seconds,
+          this.cfg
+        );
+        if (delayMs !== null) {
+          await sleep(delayMs, opts.signal);
+          return this.execute(method, url, opts, attempt + 1, refreshed);
+        }
+      }
+      const err = mapError(res.status, code, message, data, method !== "GET");
+      this.cfg.interceptors.onError?.(err);
+      throw err;
+    }
+    if (opts.rawResponse) return res;
+    if (res.status === 204) return {};
+    return await res.json();
+  }
+};
+function isRawBody(body) {
+  if (body === void 0 || body === null) return false;
+  return typeof FormData !== "undefined" && body instanceof FormData || typeof Blob !== "undefined" && body instanceof Blob || typeof ArrayBuffer !== "undefined" && (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) || typeof ReadableStream !== "undefined" && body instanceof ReadableStream || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams;
+}
+function buildQuery(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [k, v] of Object.entries(query)) {
+    if (v !== void 0) params.set(k, String(v));
+  }
+  const s = params.toString();
+  return s ? `?${s}` : "";
+}
+
+// src/auth/workspace.ts
+var WorkspaceContext = class {
+  constructor(workspaceId) {
+    this.workspaceId = workspaceId;
+  }
+  set(id) {
+    this.workspaceId = id ?? void 0;
+  }
+  get() {
+    return this.workspaceId;
+  }
+  apply(ctx, override) {
+    const ws = override ?? this.workspaceId;
+    if (ws && !ctx.headers.has("X-Workspace")) ctx.headers.set("X-Workspace", ws);
+  }
+};
+
+// src/auth/api-key.ts
+var ApiKeyCredential = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apply(ctx) {
+    ctx.headers.set("X-API-Key", this.apiKey);
+  }
+  key() {
+    return `ak:${this.apiKey.slice(-8)}`;
+  }
+};
+
+// src/auth/session-cookie.ts
+var SessionCookieCredential = class {
+  constructor(hooks = {}) {
+    this.hooks = hooks;
+  }
+  apply(ctx) {
+    if (ctx.runtime === "node") {
+      throw new DaleaError(
+        0,
+        "CONFIG",
+        "session-cookie auth is browser-only; pass an apiKey in Node"
+      );
+    }
+    ctx.includeCookies = true;
+  }
+  onResponse(res) {
+    const rotated = res.headers.get("set-auth-token");
+    if (rotated) this.hooks.onRotate?.(rotated);
+  }
+  key() {
+    return "cookie";
+  }
+};
+
+// src/auth/bearer.ts
+var BearerCredential = class {
+  constructor(token) {
+    this.token = token;
+  }
+  apply(ctx) {
+    ctx.headers.set("Authorization", `Bearer ${this.token}`);
+  }
+  key() {
+    return `b:${this.token.slice(-8)}`;
+  }
+};
+
+// src/resources/base.ts
+var Resource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+};
+
+// src/core/pagination.ts
+var DEFAULT_LIMIT = 100;
+async function* paginate(fetchPage, initialParams, walker) {
+  let params = { ...initialParams };
+  while (params) {
+    const page = await fetchPage(params);
+    for (const item of walker.items(page)) yield item;
+    params = walker.next(page, params);
+  }
+}
+function itemsAt(page, key) {
+  const arr = page[key];
+  return Array.isArray(arr) ? arr : [];
+}
+function pageLimit(raw, fallback = DEFAULT_LIMIT) {
+  return typeof raw === "number" && raw > 0 ? raw : fallback;
+}
+function nextLimit(params, fallback) {
+  return pageLimit(params.limit, fallback);
+}
+function offsetWalker(itemsKey, limit = DEFAULT_LIMIT) {
+  return {
+    items: (p) => itemsAt(p, itemsKey),
+    next: (p, params) => {
+      const got = itemsAt(p, itemsKey).length;
+      if (got === 0) return null;
+      const meta = p;
+      if (meta.hasMore === false) return null;
+      const offset = Number(params.offset ?? 0) + got;
+      if (typeof meta.total === "number" && offset >= meta.total) return null;
+      return { ...params, offset, limit: nextLimit(params, limit) };
+    }
+  };
+}
+function cursorWalker(itemsKey, limit = DEFAULT_LIMIT) {
+  return {
+    items: (p) => itemsAt(p, itemsKey),
+    next: (p, params) => {
+      const cursor = p.nextCursor;
+      return cursor ? { ...params, cursor, limit: nextLimit(params, limit) } : null;
+    }
+  };
+}
+function pageWalker(itemsKey, limit = DEFAULT_LIMIT) {
+  return {
+    items: (p) => itemsAt(p, itemsKey),
+    next: (p, params) => {
+      const got = itemsAt(p, itemsKey).length;
+      if (got === 0) return null;
+      return { ...params, page: Number(params.page ?? 0) + 1, limit: nextLimit(params, limit) };
+    }
+  };
+}
+
+// src/resources/data/tables.ts
+var enc = encodeURIComponent;
+var TablesResource = class extends Resource {
+  /** GET /tables/{id} */
+  get(id, opts) {
+    return this.transport.request("GET", `/api/v1/tables/${enc(id)}`, opts);
+  }
+  /** PATCH /tables/{id} */
+  update(id, body, opts) {
+    return this.transport.request("PATCH", `/api/v1/tables/${enc(id)}`, { ...opts, body });
+  }
+  /** POST /tables/bulk-update (conflict-aware; supports dryRun). */
+  bulkUpdate(body, opts) {
+    return this.transport.request("POST", "/api/v1/tables/bulk-update", { ...opts, body });
+  }
+  /** POST /tables/{id}/copy (dry-runnable). */
+  copy(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/tables/${enc(id)}/copy`, { ...opts, body });
+  }
+  /** POST /tables/{id}/move (dry-runnable). */
+  move(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/tables/${enc(id)}/move`, { ...opts, body });
+  }
+  /** POST /tables/bulk-copy (dry-runnable). */
+  bulkCopy(body, opts) {
+    return this.transport.request("POST", "/api/v1/tables/bulk-copy", { ...opts, body });
+  }
+  /** POST /tables/bulk-move (dry-runnable). */
+  bulkMove(body, opts) {
+    return this.transport.request("POST", "/api/v1/tables/bulk-move", { ...opts, body });
+  }
+  // --- columns scoped to a table ---
+  /** GET /tables/{tableId}/columns */
+  listColumns(tableId, params, opts) {
+    return this.transport.request("GET", `/api/v1/tables/${enc(tableId)}/columns`, {
+      ...opts,
+      query: params
+    });
+  }
+  /** GET /tables/{tableId}/columns/archived */
+  listArchivedColumns(tableId, opts) {
+    return this.transport.request("GET", `/api/v1/tables/${enc(tableId)}/columns/archived`, opts);
+  }
+  /** POST /tables/{tableId}/columns */
+  createColumn(tableId, body, opts) {
+    return this.transport.request("POST", `/api/v1/tables/${enc(tableId)}/columns`, { ...opts, body });
+  }
+  /** POST /tables/{tableId}/columns/bulk (conflict-aware; supports dryRun). */
+  bulkCreateColumns(tableId, body, opts) {
+    return this.transport.request("POST", `/api/v1/tables/${enc(tableId)}/columns/bulk`, { ...opts, body });
+  }
+  // --- objects scoped to a table ---
+  /** GET /tables/{tableId}/objects */
+  listObjects(tableId, params, opts) {
+    return this.transport.request("GET", `/api/v1/tables/${enc(tableId)}/objects`, {
+      ...opts,
+      query: params
+    });
+  }
+  /**
+   * GET /tables/{tableId}/objects — auto-paged: yields every object across all
+   * pages. `for await (const obj of …)`; `break` stops fetching. Cancellation
+   * rides `opts.signal`.
+   */
+  iterateObjects(tableId, params, opts) {
+    const limit = pageLimit(params?.limit);
+    return paginate(
+      (p) => this.listObjects(tableId, p, opts),
+      { offset: 0, ...params, limit },
+      offsetWalker("objects", limit)
+    );
+  }
+  /** GET /tables/{tableId}/objects/archived */
+  listArchivedObjects(tableId, params, opts) {
+    return this.transport.request("GET", `/api/v1/tables/${enc(tableId)}/objects/archived`, {
+      ...opts,
+      query: params
+    });
+  }
+  /** GET /tables/{tableId}/objects/archived — auto-paged over every archived object. */
+  iterateArchivedObjects(tableId, params, opts) {
+    const limit = pageLimit(params?.limit);
+    return paginate(
+      (p) => this.listArchivedObjects(tableId, p, opts),
+      { offset: 0, ...params, limit },
+      offsetWalker("objects", limit)
+    );
+  }
+  /** GET /tables/{tableId}/objects/search */
+  searchObjects(tableId, params, opts) {
+    return this.transport.request("GET", `/api/v1/tables/${enc(tableId)}/objects/search`, {
+      ...opts,
+      query: params
+    });
+  }
+  /** GET /tables/{tableId}/objects/search — auto-paged over every match. */
+  searchObjectsAll(tableId, params, opts) {
+    const limit = pageLimit(params?.limit);
+    return paginate(
+      (p) => this.searchObjects(tableId, p, opts),
+      { offset: 0, ...params, limit },
+      offsetWalker("objects", limit)
+    );
+  }
+  /** POST /tables/{tableId}/objects */
+  createObject(tableId, body, opts) {
+    return this.transport.request("POST", `/api/v1/tables/${enc(tableId)}/objects`, { ...opts, body });
+  }
+  /** POST /tables/{tableId}/objects/bulk (partial success → 207). */
+  bulkCreateObjects(tableId, body, opts) {
+    return this.transport.request("POST", `/api/v1/tables/${enc(tableId)}/objects/bulk`, { ...opts, body });
+  }
+  /** POST /tables/{tableId}/objects/validate-bulk (dry-run; no writes). */
+  validateBulkObjects(tableId, body, opts) {
+    return this.transport.request("POST", `/api/v1/tables/${enc(tableId)}/objects/validate-bulk`, {
+      ...opts,
+      body
+    });
+  }
+  // --- archive / restore / permanent-delete ---
+  /** POST /tables/{id}/archive — soft-archive (reversible); requires a reason. */
+  archive(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/tables/${enc(id)}/archive`, { ...opts, body });
+  }
+  /** POST /tables/{id}/restore — restore an archived table. */
+  restore(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/tables/${enc(id)}/restore`, { ...opts, body });
+  }
+};
+
+// src/resources/data/columns.ts
+var enc2 = encodeURIComponent;
+var ColumnsResource = class extends Resource {
+  /** GET /columns/{id} */
+  get(id, opts) {
+    return this.transport.request("GET", `/api/v1/columns/${enc2(id)}`, opts);
+  }
+  /** PATCH /columns/{id} */
+  update(id, body, opts) {
+    return this.transport.request("PATCH", `/api/v1/columns/${enc2(id)}`, { ...opts, body });
+  }
+  /** POST /columns/bulk-update (conflict-aware; partial success → 207). */
+  bulkUpdate(body, opts) {
+    return this.transport.request("POST", "/api/v1/columns/bulk-update", { ...opts, body });
+  }
+  // --- archive / restore / permanent-delete ---
+  /** POST /columns/{id}/archive — soft-archive (reversible); requires a reason. */
+  archive(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/columns/${enc2(id)}/archive`, { ...opts, body });
+  }
+  /** POST /columns/{id}/restore — restore an archived column. */
+  restore(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/columns/${enc2(id)}/restore`, { ...opts, body });
+  }
+};
+
+// src/resources/data/naming-schemes.ts
+var enc3 = encodeURIComponent;
+var NamingSchemesResource = class extends Resource {
+  /** GET /naming-schemes */
+  list(opts) {
+    return this.transport.request("GET", "/api/v1/naming-schemes", opts);
+  }
+  /** POST /naming-schemes */
+  create(body, opts) {
+    return this.transport.request("POST", "/api/v1/naming-schemes", { ...opts, body });
+  }
+  /** GET /naming-schemes/{id} */
+  get(id, opts) {
+    return this.transport.request("GET", `/api/v1/naming-schemes/${enc3(id)}`, opts);
+  }
+  /** PATCH /naming-schemes/{id} */
+  update(id, body, opts) {
+    return this.transport.request("PATCH", `/api/v1/naming-schemes/${enc3(id)}`, { ...opts, body });
+  }
+  /** POST /naming-schemes/{id}/generate — the next ID from the scheme. */
+  generateNextId(id, opts) {
+    return this.transport.request("POST", `/api/v1/naming-schemes/${enc3(id)}/generate`, opts);
+  }
+};
+
+// src/resources/data/objects.ts
+var enc4 = encodeURIComponent;
+var ObjectsResource = class extends Resource {
+  /** POST /objects/resolve — batch-resolve objects by ID (max 100). */
+  resolve(body, opts) {
+    return this.transport.request("POST", "/api/v1/objects/resolve", { ...opts, body });
+  }
+  /** GET /objects/{id} */
+  get(id, opts) {
+    return this.transport.request("GET", `/api/v1/objects/${enc4(id)}`, opts);
+  }
+  /** GET /objects/{id}/context — object with its table, environment, and columns. */
+  getWithContext(id, opts) {
+    return this.transport.request("GET", `/api/v1/objects/${enc4(id)}/context`, opts);
+  }
+  /** GET /objects/{id}/references — incoming references (reverse lookup). */
+  getReferences(id, params, opts) {
+    return this.transport.request("GET", `/api/v1/objects/${enc4(id)}/references`, {
+      ...opts,
+      query: params
+    });
+  }
+  /** PATCH /objects/{id} */
+  update(id, body, opts) {
+    return this.transport.request("PATCH", `/api/v1/objects/${enc4(id)}`, { ...opts, body });
+  }
+  /** POST /objects/bulk-update (partial success → 207). */
+  bulkUpdate(body, opts) {
+    return this.transport.request("POST", "/api/v1/objects/bulk-update", { ...opts, body });
+  }
+  // --- archive / restore / permanent-delete (single + bulk) ---
+  /** POST /objects/{id}/archive — soft-archive (reversible); requires a reason. */
+  archive(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/objects/${enc4(id)}/archive`, { ...opts, body });
+  }
+  /** POST /objects/{id}/restore — restore an archived object. */
+  restore(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/objects/${enc4(id)}/restore`, { ...opts, body });
+  }
+  /** POST /objects/bulk-archive — archive many objects (per-id failures aggregated). */
+  bulkArchive(body, opts) {
+    return this.transport.request("POST", "/api/v1/objects/bulk-archive", { ...opts, body });
+  }
+  /** POST /objects/bulk-restore — restore many archived objects. */
+  bulkRestore(body, opts) {
+    return this.transport.request("POST", "/api/v1/objects/bulk-restore", { ...opts, body });
+  }
+};
+
+// src/resources/data/saved-queries.ts
+var enc5 = encodeURIComponent;
+var SavedQueriesResource = class extends Resource {
+  /** GET /queries */
+  list(params, opts) {
+    return this.transport.request("GET", "/api/v1/queries", { ...opts, query: params });
+  }
+  /** GET /queries — auto-paged over every saved query. */
+  iterate(params, opts) {
+    const limit = pageLimit(params?.limit);
+    return paginate(
+      (p) => this.list(p, opts),
+      { offset: 0, ...params, limit },
+      offsetWalker("queries", limit)
+    );
+  }
+  /** POST /queries */
+  create(body, params, opts) {
+    return this.transport.request("POST", "/api/v1/queries", { ...opts, body, query: params });
+  }
+  /** GET /queries/{queryId} */
+  get(queryId, params, opts) {
+    return this.transport.request("GET", `/api/v1/queries/${enc5(queryId)}`, {
+      ...opts,
+      query: params
+    });
+  }
+  /** PATCH /queries/{queryId} */
+  update(queryId, body, params, opts) {
+    return this.transport.request("PATCH", `/api/v1/queries/${enc5(queryId)}`, {
+      ...opts,
+      body,
+      query: params
+    });
+  }
+  /** POST /queries/{queryId}/duplicate */
+  duplicate(queryId, body, opts) {
+    return this.transport.request("POST", `/api/v1/queries/${enc5(queryId)}/duplicate`, { ...opts, body });
+  }
+  /** POST /queries/{queryId}/execute — runs the query, returns the raw result. */
+  execute(queryId, body, opts) {
+    return this.transport.request("POST", `/api/v1/queries/${enc5(queryId)}/execute`, { ...opts, body });
+  }
+};
+
+// src/resources/data/query.ts
+var enc6 = encodeURIComponent;
+var QueryResource = class extends Resource {
+  /** POST /environments/{envId}/query */
+  execute(envId, body, params, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc6(envId)}/query`, {
+      ...opts,
+      body,
+      query: params
+    });
+  }
+  /** POST /environments/{envId}/query/preview — generated SQL, no execution. */
+  preview(envId, body, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc6(envId)}/query/preview`, { ...opts, body });
+  }
+  /** POST /environments/{envId}/query/sql — read-only raw SQL (SELECT only). */
+  sql(envId, body, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc6(envId)}/query/sql`, { ...opts, body });
+  }
+};
+
+// src/resources/data/results.ts
+var enc7 = encodeURIComponent;
+var ResultsResource = class extends Resource {
+  /** GET /results/schemas/{schemaId}/describe — fillable template + columns. */
+  describeSchema(schemaId, opts) {
+    return this.transport.request("GET", `/api/v1/results/schemas/${enc7(schemaId)}/describe`, opts);
+  }
+  /** POST /results/batches/validate — dry-run validation (no writes). */
+  validateBatch(body, opts) {
+    return this.transport.request("POST", "/api/v1/results/batches/validate", { ...opts, body });
+  }
+  /** POST /results/batches — create a batch (partial success → 207). */
+  createBatch(body, opts) {
+    return this.transport.request("POST", "/api/v1/results/batches", { ...opts, body });
+  }
+  /** GET /results/batches */
+  listBatches(params, opts) {
+    return this.transport.request("GET", "/api/v1/results/batches", {
+      ...opts,
+      query: params
+    });
+  }
+  /** GET /results/batches/{id} */
+  getBatch(id, opts) {
+    return this.transport.request("GET", `/api/v1/results/batches/${enc7(id)}`, opts);
+  }
+  /** POST /results/batches/{id}/supersede — re-record (partial success → 207). */
+  supersedeBatch(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/results/batches/${enc7(id)}/supersede`, { ...opts, body });
+  }
+  /** GET /results/records — list records (filterable, paginated). */
+  listRecords(params, opts) {
+    return this.transport.request("GET", "/api/v1/results/records", {
+      ...opts,
+      query: params
+    });
+  }
+  /** GET /results/records/by-object/{objectId} — reverse lookup. */
+  recordsByObject(objectId, opts) {
+    return this.transport.request("GET", `/api/v1/results/records/by-object/${enc7(objectId)}`, opts);
+  }
+  /** POST /results/query — analytical query (filter, group, aggregate). */
+  query(body, opts) {
+    return this.transport.request("POST", "/api/v1/results/query", { ...opts, body });
+  }
+  // --- result-batch archive / restore / permanent-delete ---
+  /** POST /result-batches/{id}/archive — soft-archive a batch (reversible). */
+  archiveBatch(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/result-batches/${enc7(id)}/archive`, { ...opts, body });
+  }
+  /** POST /result-batches/{id}/restore — restore an archived batch. */
+  restoreBatch(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/result-batches/${enc7(id)}/restore`, { ...opts, body });
+  }
+};
+
+// src/resources/data/schema.ts
+var enc8 = encodeURIComponent;
+var SchemaResource = class extends Resource {
+  /** POST /environments/{envId}/schema/validate — detect conflicts (no writes). */
+  validate(envId, body, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc8(envId)}/schema/validate`, { ...opts, body });
+  }
+  /** GET /environments/{envId}/schema/jobs/{jobId} — async migration status. */
+  jobStatus(envId, jobId, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc8(envId)}/schema/jobs/${enc8(jobId)}`, opts);
+  }
+};
+
+// src/resources/data/environments.ts
+var enc9 = encodeURIComponent;
+var EnvironmentsResource = class extends Resource {
+  /** GET /environments */
+  list(opts) {
+    return this.transport.request("GET", "/api/v1/environments", opts);
+  }
+  /** POST /environments */
+  create(body, opts) {
+    return this.transport.request("POST", "/api/v1/environments", { ...opts, body });
+  }
+  /** GET /environments/archived */
+  listArchived(opts) {
+    return this.transport.request("GET", "/api/v1/environments/archived", opts);
+  }
+  /** GET /environments/{id} */
+  get(id, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(id)}`, opts);
+  }
+  /** PATCH /environments/{id} */
+  update(id, body, opts) {
+    return this.transport.request("PATCH", `/api/v1/environments/${enc9(id)}`, { ...opts, body });
+  }
+  // --- staging snapshot ---
+  /** GET /environments/{id}/staging */
+  getStaging(id, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(id)}/staging`, opts);
+  }
+  /** GET /environments/{id}/staging/version — cheap version poll. */
+  getStagingVersion(id, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(id)}/staging/version`, opts);
+  }
+  /** POST /environments/{id}/staging/resync — reset staging to live. */
+  resyncStaging(id, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc9(id)}/staging/resync`, opts);
+  }
+  // --- linkage / references ---
+  /** PATCH /environments/{id}/source-market */
+  setSourceMarket(id, body, opts) {
+    return this.transport.request("PATCH", `/api/v1/environments/${enc9(id)}/source-market`, { ...opts, body });
+  }
+  /** POST /environments/{id}/detach — break the marketplace link (make editable). */
+  detach(id, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc9(id)}/detach`, opts);
+  }
+  /** GET /environments/{id}/cross-references */
+  crossReferences(id, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(id)}/cross-references`, opts);
+  }
+  // --- env-scoped collections ---
+  /** GET /environments/{envId}/tables (?source=staging for the proposed schema). */
+  listTables(envId, params, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(envId)}/tables`, {
+      ...opts,
+      query: params
+    });
+  }
+  /** GET /environments/{envId}/columns (?source=staging for the proposed schema). */
+  listColumns(envId, params, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(envId)}/columns`, {
+      ...opts,
+      query: params
+    });
+  }
+  /** GET /environments/{envId}/relationships — every reference edge. */
+  listRelationships(envId, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(envId)}/relationships`, opts);
+  }
+  /** GET /environments/{envId}/tables/{tableId}/relationships */
+  listTableRelationships(envId, tableId, opts) {
+    return this.transport.request(
+      "GET",
+      `/api/v1/environments/${enc9(envId)}/tables/${enc9(tableId)}/relationships`,
+      opts
+    );
+  }
+  /** GET /environments/{envId}/tables/archived */
+  listArchivedTables(envId, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(envId)}/tables/archived`, opts);
+  }
+  /** POST /environments/{envId}/tables */
+  createTable(envId, body, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc9(envId)}/tables`, { ...opts, body });
+  }
+  /** POST /environments/{envId}/tables/bulk (partial success → 207). */
+  bulkCreateTables(envId, body, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc9(envId)}/tables/bulk`, { ...opts, body });
+  }
+  /** GET /environments/{envId}/objects/search */
+  searchObjects(envId, params, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(envId)}/objects/search`, {
+      ...opts,
+      query: params
+    });
+  }
+  // --- import / export ---
+  /** POST /environments/import — import an EnvironmentPackage. */
+  importPackage(body, opts) {
+    return this.transport.request("POST", "/api/v1/environments/import", { ...opts, body });
+  }
+  /** GET /environments/{id}/export — export to EnvironmentPackage. */
+  exportPackage(id, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(id)}/export`, opts);
+  }
+  /** POST /environments/{id}/data/import — import a data package (dry-runnable). */
+  importData(id, body, params, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc9(id)}/data/import`, {
+      ...opts,
+      body,
+      query: params
+    });
+  }
+  /** POST /environments/{id}/data/import/apply — structured spreadsheet import. */
+  applyImport(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc9(id)}/data/import/apply`, { ...opts, body });
+  }
+  /** POST /environments/{id}/tables/{tableId}/export — export a table to a CSV file. */
+  exportTableCsv(id, tableId, body, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc9(id)}/tables/${enc9(tableId)}/export`, {
+      ...opts,
+      body
+    });
+  }
+  /** GET /environments/{id}/data/export — export environment data (?tables=id1,id2). */
+  exportData(id, params, opts) {
+    return this.transport.request("GET", `/api/v1/environments/${enc9(id)}/data/export`, {
+      ...opts,
+      query: params
+    });
+  }
+  // --- archive / restore / permanent-delete (cascades to descendants) ---
+  /** POST /environments/{id}/archive — soft-archive (reversible); requires a reason. */
+  archive(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc9(id)}/archive`, { ...opts, body });
+  }
+  /** POST /environments/{id}/restore — restore an archived environment. */
+  restore(id, body, opts) {
+    return this.transport.request("POST", `/api/v1/environments/${enc9(id)}/restore`, { ...opts, body });
+  }
+};
+
+// src/resources/data/import-mappings.ts
+var enc10 = encodeURIComponent;
+var ImportMappingsResource = class extends Resource {
+  /** GET /import-mappings?environmentId= — active mappings for an environment. */
+  list(params, opts) {
+    return this.transport.request("GET", "/api/v1/import-mappings", {
+      ...opts,
+      query: params
+    });
+  }
+  /** GET /import-mappings/{mappingId} — a mapping with its full entries. */
+  get(mappingId, opts) {
+    return this.transport.request("GET", `/api/v1/import-mappings/${enc10(mappingId)}`, opts);
+  }
+  /** POST /import-mappings */
+  create(data, opts) {
+    return this.transport.request("POST", "/api/v1/import-mappings", { ...opts, body: data });
+  }
+  /** PATCH /import-mappings/{mappingId} */
+  update(mappingId, data, opts) {
+    return this.transport.request("PATCH", `/api/v1/import-mappings/${enc10(mappingId)}`, { ...opts, body: data });
+  }
+  /** POST /import-mappings/{mappingId}/archive (reversible soft-delete). */
+  archive(mappingId, payload, opts) {
+    return this.transport.request("POST", `/api/v1/import-mappings/${enc10(mappingId)}/archive`, {
+      ...opts,
+      body: payload
+    });
+  }
+  /** POST /import-mappings/{mappingId}/restore */
+  restore(mappingId, payload, opts) {
+    return this.transport.request("POST", `/api/v1/import-mappings/${enc10(mappingId)}/restore`, {
+      ...opts,
+      body: payload
+    });
+  }
+  /** GET /import-mappings/{mappingId}/file-overviews — source sheets + headers. */
+  getFileOverviews(mappingId, opts) {
+    return this.transport.request("GET", `/api/v1/import-mappings/${enc10(mappingId)}/file-overviews`, opts);
+  }
+  /** GET /import-mappings/{mappingId}/audit — per-mapping audit trail. */
+  getAuditTrail(mappingId, params, opts) {
+    return this.transport.request("GET", `/api/v1/import-mappings/${enc10(mappingId)}/audit`, {
+      ...opts,
+      query: params
+    });
+  }
+};
+
+// src/resources/data/index.ts
+var DataResource = class {
+  environments;
+  tables;
+  columns;
+  namingSchemes;
+  objects;
+  savedQueries;
+  query;
+  results;
+  schema;
+  importMappings;
+  constructor(transport) {
+    this.environments = new EnvironmentsResource(transport);
+    this.tables = new TablesResource(transport);
+    this.columns = new ColumnsResource(transport);
+    this.namingSchemes = new NamingSchemesResource(transport);
+    this.objects = new ObjectsResource(transport);
+    this.savedQueries = new SavedQueriesResource(transport);
+    this.query = new QueryResource(transport);
+    this.results = new ResultsResource(transport);
+    this.schema = new SchemaResource(transport);
+    this.importMappings = new ImportMappingsResource(transport);
+  }
+};
+
+// src/client.ts
+function readEnv(name) {
+  return typeof process !== "undefined" && process.env ? process.env[name] : void 0;
+}
+function credentialFromConfig(cfg) {
+  if (cfg.credential) return cfg.credential;
+  if (cfg.apiKey) return new ApiKeyCredential(cfg.apiKey);
+  if (cfg.sessionCookie) return new SessionCookieCredential();
+  const envKey = readEnv("DALEA_API_KEY");
+  if (envKey) return new ApiKeyCredential(envKey);
+  throw new Error(
+    "DaleaClient: provide one of { apiKey, sessionCookie, credential }, or set the DALEA_API_KEY env var"
+  );
+}
+var DaleaClient = class {
+  resolved;
+  serviceUrls;
+  workspace;
+  data;
+  constructor(cfg) {
+    this.resolved = resolveConfig(cfg);
+    this.serviceUrls = cfg.serviceUrls ?? {};
+    this.workspace = new WorkspaceContext(cfg.workspace);
+    const credential = credentialFromConfig(cfg);
+    this.data = new DataResource(this.transportFor("data", credential));
+  }
+  // A transport bound to the domain's base URL (a per-service override, or the
+  // shared baseUrl when none is set). Shares the resolved config and workspace.
+  transportFor(domain, credential) {
+    const override = this.serviceUrls[domain];
+    const resolved = override !== void 0 && override !== this.resolved.baseUrl ? { ...this.resolved, baseUrl: override } : this.resolved;
+    return new Transport(resolved, credential, this.workspace);
+  }
+  /** Set the default workspace (X-Workspace) for subsequent calls. */
+  setWorkspace(id) {
+    this.workspace.set(id);
+  }
+  /**
+   * Returns a lightweight view authenticated with a per-call bearer token,
+   * sharing this client's config, interceptors and workspace context. Useful for
+   * authenticating individual requests with a caller-supplied token.
+   */
+  as(token) {
+    const credential = new BearerCredential(token);
+    return {
+      data: new DataResource(this.transportFor("data", credential))
+    };
+  }
+};
+
+// src/auth/oauth-pkce.ts
+var OAuthPkceCredential = class _OAuthPkceCredential {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.tokens = cfg.tokens;
+    this.fetchImpl = cfg.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!this.fetchImpl) {
+      throw new Error("OAuthPkceCredential: no global fetch available; pass cfg.fetch");
+    }
+  }
+  tokens;
+  fetchImpl;
+  apply(ctx) {
+    ctx.headers.set("Authorization", `Bearer ${this.tokens.accessToken}`);
+  }
+  /**
+   * Called by the transport on a 401. Exchanges the refresh token for a fresh
+   * access token and returns `true` so the request is replayed ONCE. Returns
+   * `false` (no retry — the original 401 surfaces) when there is no refresh token
+   * or the grant fails, so a revoked session can't spin in a refresh loop.
+   */
+  async refresh() {
+    if (!this.tokens.refreshToken) return false;
+    try {
+      await this.grant({
+        grant_type: "refresh_token",
+        refresh_token: this.tokens.refreshToken,
+        client_id: this.cfg.clientId,
+        ...this.cfg.clientSecret ? { client_secret: this.cfg.clientSecret } : {}
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Stable-ish dedup id; the access-token suffix changes only on the rare refresh. */
+  key() {
+    return `oauth:${this.tokens.accessToken.slice(-8)}`;
+  }
+  /** The tokens this credential currently holds (post-refresh / post-exchange). */
+  currentTokens() {
+    return this.tokens;
+  }
+  // POST the token endpoint as `application/x-www-form-urlencoded`, adopt the
+  // returned tokens, and notify `onTokens`. Shared by refresh() + exchangeCode().
+  async grant(body) {
+    const res = await this.fetchImpl(this.cfg.tokenEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams(body).toString()
+    });
+    if (!res.ok) {
+      throw new Error(`OAuth token endpoint returned ${res.status}`);
+    }
+    const json = await res.json();
+    const next = {
+      accessToken: json.access_token,
+      // A refresh response may omit refresh_token (non-rotating servers) — keep the old one.
+      refreshToken: json.refresh_token ?? this.tokens.refreshToken,
+      expiresAt: typeof json.expires_in === "number" ? Date.now() + json.expires_in * 1e3 : void 0
+    };
+    this.tokens = next;
+    this.cfg.onTokens?.(next);
+    return next;
+  }
+  /**
+   * Exchange a PKCE authorization code for tokens and return a ready credential.
+   * Run after the user is redirected back with `?code=…`; pass the `codeVerifier`
+   * from the matching `generatePkcePair()` call.
+   */
+  static async exchangeCode(params) {
+    const cred = new _OAuthPkceCredential({
+      tokenEndpoint: params.tokenEndpoint,
+      clientId: params.clientId,
+      clientSecret: params.clientSecret,
+      onTokens: params.onTokens,
+      fetch: params.fetch,
+      // Placeholder — replaced by the grant below before the credential is used.
+      tokens: { accessToken: "" }
+    });
+    await cred.grant({
+      grant_type: "authorization_code",
+      code: params.code,
+      code_verifier: params.codeVerifier,
+      redirect_uri: params.redirectUri,
+      client_id: params.clientId,
+      ...params.clientSecret ? { client_secret: params.clientSecret } : {}
+    });
+    return cred;
+  }
+  /**
+   * Generate a PKCE `code_verifier` + S256 `code_challenge`. Stash the verifier
+   * (e.g. sessionStorage) and send the challenge to the authorize endpoint with
+   * `code_challenge_method=S256`. Uses Web Crypto (browser / Node 18+ / edge).
+   */
+  static async generatePkcePair() {
+    const verifierBytes = crypto.getRandomValues(new Uint8Array(32));
+    const codeVerifier = base64UrlEncode(verifierBytes);
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(codeVerifier));
+    return { codeVerifier, codeChallenge: base64UrlEncode(new Uint8Array(digest)) };
+  }
+};
+function base64UrlEncode(bytes) {
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  const base64 = typeof btoa === "function" ? btoa(binary) : Buffer.from(bytes).toString("base64");
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+// src/auth/oauth-client-credentials.ts
+var OAuthClientCredentialsCredential = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.skewMs = cfg.expirySkewMs ?? 6e4;
+    this.fetchImpl = cfg.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!this.fetchImpl) {
+      throw new Error("OAuthClientCredentialsCredential: no global fetch available; pass cfg.fetch");
+    }
+  }
+  accessToken;
+  expiresAt = 0;
+  // epoch ms
+  inflight;
+  skewMs;
+  fetchImpl;
+  /** Ensure a fresh token, then set the bearer header. `apply` is awaited by the transport. */
+  async apply(ctx) {
+    await this.ensureToken();
+    ctx.headers.set("Authorization", `Bearer ${this.accessToken}`);
+  }
+  /** Force a re-mint on a 401 (e.g. the token was revoked mid-life); retry once. */
+  async refresh() {
+    this.inflight = void 0;
+    this.expiresAt = 0;
+    try {
+      await this.ensureToken();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  key() {
+    return `cc:${this.cfg.clientId.slice(-8)}`;
+  }
+  // Mint lazily, coalescing concurrent callers onto one in-flight request so a
+  // burst of parallel calls doesn't hammer the token endpoint.
+  ensureToken() {
+    if (this.accessToken && Date.now() < this.expiresAt - this.skewMs) return Promise.resolve();
+    this.inflight ??= this.mint().finally(() => {
+      this.inflight = void 0;
+    });
+    return this.inflight;
+  }
+  async mint() {
+    const body = {
+      grant_type: "client_credentials",
+      client_id: this.cfg.clientId,
+      client_secret: this.cfg.clientSecret
+    };
+    if (this.cfg.scope) body.scope = this.cfg.scope;
+    const res = await this.fetchImpl(this.cfg.tokenEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams(body).toString()
+    });
+    if (!res.ok) {
+      throw new Error(`OAuth token endpoint returned ${res.status}`);
+    }
+    const json = await res.json();
+    this.accessToken = json.access_token;
+    this.expiresAt = Date.now() + (typeof json.expires_in === "number" ? json.expires_in : 3600) * 1e3;
+  }
+};
+
+// src/core/sse.ts
+async function* parseSSE(response) {
+  const body = response.body;
+  if (!body) {
+    throw new DaleaNetworkError(0, "NO_STREAM_BODY", "Streaming response had no body", void 0, true);
+  }
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const frame = (line) => {
+    if (!line.startsWith("data:")) return null;
+    const data = line.slice(5).trim();
+    if (data === "") return null;
+    if (data === "[DONE]") return { done: true };
+    try {
+      return [JSON.parse(data)];
+    } catch {
+      return null;
+    }
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        const tail = frame(buffer);
+        if (tail && !("done" in tail)) yield tail[0];
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const f = frame(line);
+        if (f === null) continue;
+        if ("done" in f) return;
+        yield f[0];
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    void body.cancel().catch(() => {
+    });
+  }
+}
+
+export { ApiKeyCredential, BearerCredential, DaleaArchivedError, DaleaAuthError, DaleaBannedError, DaleaClient, DaleaConflictError, DaleaError, DaleaNetworkError, DaleaNotFoundError, DaleaPermissionError, DaleaQuotaError, DaleaRateLimitError, DaleaServerError, DaleaValidationError, OAuthClientCredentialsCredential, OAuthPkceCredential, PERMISSION_DENIED_CODES, SDK_VERSION, SessionCookieCredential, WorkspaceContext, cursorWalker, offsetWalker, pageLimit, pageWalker, paginate, parseSSE };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map