@treeseed/sdk 0.10.28 → 0.11.0

package/dist/treedx/client.js

@@ -0,0 +1,871 @@
+import { TreeDxApiError } from "./errors.js";
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/u, "");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+function stripOk(payload) {
+  if (!isRecord(payload)) {
+    return payload;
+  }
+  const { ok: _ok, ...rest } = payload;
+  return rest;
+}
+function firstPayload(payload, keys) {
+  if (isRecord(payload)) {
+    for (const key of keys) {
+      if (key in payload) {
+        return payload[key];
+      }
+    }
+  }
+  return stripOk(payload);
+}
+const TREEDX_CLIENT_OPERATION_MAP = {
+  health: "getHealth",
+  ready: "getReadiness",
+  deepHealth: "getDeepHealth",
+  adminDeepHealth: "getAdminDeepHealth",
+  metrics: "getMetrics",
+  prometheusMetrics: "getPrometheusMetrics",
+  whoami: "getWhoami",
+  authMode: "getAuthMode",
+  effectiveScope: "getEffectiveScope",
+  listCapabilities: "listCapabilities",
+  listCapabilityGrants: "listCapabilityGrants",
+  putCapabilityGrant: "putCapabilityGrant",
+  listAuditEvents: "listAuditEvents",
+  planFederatedQuery: "planFederationQuery",
+  buildSnapshot: "buildSnapshot",
+  getSnapshot: "getSnapshot",
+  exportArtifact: "exportArtifact",
+  syncMirror: "syncMirror",
+  fetchRemote: "syncRepository",
+  push: "pushRepository",
+  checkMirrorHealth: "checkMirrorHealth",
+  promoteMirror: "promoteMirror",
+  compactStorage: "compactAdminStorage",
+  backupStorage: "backupAdminStorage",
+  listStorageMigrations: "listStorageMigrations",
+  planStorageMigration: "planStorageMigration",
+  applyStorageMigration: "applyStorageMigration",
+  rollbackStorageMigration: "rollbackStorageMigration",
+  verifyStorageRestore: "verifyStorageRestore",
+  restoreStorage: "restoreStorage",
+  createMigration: "createMigration",
+  getMigration: "getMigration",
+  getNode: "getLocalNode",
+  listNodes: "listRegistryNodes",
+  getPlacement: "getRepositoryPlacement",
+  getRepository: "getRepository",
+  createWorkspace: "createWorkspace",
+  closeWorkspace: "closeWorkspace",
+  listTree: "listWorkspaceTree",
+  readFile: "readWorkspaceFile",
+  writeFile: "writeWorkspaceFile",
+  patchFile: "patchWorkspaceFile",
+  deleteFile: "deleteWorkspaceFile",
+  readBlob: "readRepositoryBlob",
+  writeBlob: "writeWorkspaceBlob",
+  deleteBlob: "deleteWorkspaceBlob",
+  downloadBlob: "downloadWorkspaceBlob",
+  uploadBlob: "uploadWorkspaceBlob",
+  createBlobUpload: "createWorkspaceBlobUpload",
+  uploadBlobPart: "uploadWorkspaceBlobPart",
+  completeBlobUpload: "completeWorkspaceBlobUpload",
+  abortBlobUpload: "abortWorkspaceBlobUpload",
+  listArtifacts: "listArtifacts",
+  getArtifact: "getArtifact",
+  deleteArtifact: "deleteArtifact",
+  cleanupArtifacts: "cleanupArtifacts",
+  search: "searchWorkspace",
+  status: "getWorkspaceStatus",
+  diff: "getWorkspaceDiff",
+  commit: "commitWorkspace",
+  exec: "execWorkspace",
+  readRepositoryFiles: "readRepositoryFile",
+  readRepositoryFile: "readRepositoryFile",
+  listRepositoryPaths: "listRepositoryPaths",
+  searchRepositoryFiles: "searchRepositoryFiles",
+  queryRepository: "queryRepository",
+  federatedSearch: "federatedSearch",
+  federatedQuery: "federatedQuery",
+  federatedContext: "federatedContextBuild",
+  federatedGraph: "federatedGraphQuery",
+  refreshGraph: "refreshRepositoryGraph",
+  getGraphRefreshJob: "getGraphRefreshJob",
+  refreshSearchIndex: "refreshSearchIndex",
+  getSearchIndexStatus: "getSearchIndexStatus",
+  compactSearchIndex: "compactSearchIndex",
+  queryGraph: "queryRepositoryGraph",
+  searchGraphFiles: "searchGraphFiles",
+  searchGraphSections: "searchGraphSections",
+  searchGraphEntities: "searchGraphEntities",
+  getGraphNode: "getGraphNode",
+  getRelated: "getRelatedGraphNodes",
+  getSubgraph: "getGraphSubgraph",
+  buildContext: "buildContext",
+  parseContextDsl: "parseContextQuery"
+};
+class TreeDxClient {
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
+    this.token = options.token;
+    this.defaultRepoId = options.repoId;
+    this.fetchImpl = options.fetch ?? fetch;
+  }
+  options;
+  baseUrl;
+  token;
+  defaultRepoId;
+  fetchImpl;
+  repoId(inputRepoId) {
+    const repoId = inputRepoId ?? this.defaultRepoId;
+    if (!repoId) {
+      throw new TreeDxApiError("TreeDX repository ID is required.", {
+        status: 400,
+        code: "missing_repo_id"
+      });
+    }
+    return repoId;
+  }
+  query(params = {}) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      search.set(key, String(value));
+    }
+    const rendered = search.toString();
+    return rendered ? `?${rendered}` : "";
+  }
+  headers(bodyPresent) {
+    const headers = {
+      accept: "application/json"
+    };
+    if (bodyPresent) {
+      headers["content-type"] = "application/json";
+    }
+    if (this.token) {
+      headers.authorization = `Bearer ${this.token}`;
+    }
+    return headers;
+  }
+  async fetchWithTimeout(input, init) {
+    const timeoutMs = this.options.timeoutMs;
+    let timeout;
+    let controller;
+    if (timeoutMs && timeoutMs > 0) {
+      controller = new AbortController();
+      timeout = setTimeout(() => controller?.abort(), timeoutMs);
+    }
+    try {
+      return await this.fetchImpl(input, {
+        ...init,
+        signal: controller?.signal ?? init.signal
+      });
+    } catch (error) {
+      if (isAbortError(error)) {
+        throw new TreeDxApiError(`TreeDX request timed out after ${timeoutMs}ms.`, {
+          status: 0,
+          code: "timeout",
+          details: { timeoutMs },
+          payload: error
+        });
+      }
+      throw new TreeDxApiError(error instanceof Error ? error.message : "TreeDX network request failed.", {
+        status: 0,
+        code: "network_error",
+        payload: error
+      });
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  }
+  async request(method, path, body, options = {}) {
+    if (options.tokenRequired && !this.token) {
+      throw new TreeDxApiError("TreeDX bearer token is required.", {
+        status: 401,
+        code: "missing_token"
+      });
+    }
+    const response = await this.fetchWithTimeout(`${this.baseUrl}${path}${this.query(options.query ?? {})}`, {
+      method,
+      headers: this.headers(body !== void 0),
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    let payload;
+    try {
+      payload = await response.json();
+    } catch (error) {
+      throw new TreeDxApiError("TreeDX response was not valid JSON.", {
+        status: response.status,
+        code: "invalid_response",
+        payload: error
+      });
+    }
+    if (!response.ok || isRecord(payload) && payload.ok === false) {
+      const errorBody = isRecord(payload) && isRecord(payload.error) ? payload.error : {};
+      throw new TreeDxApiError(
+        typeof errorBody.message === "string" ? errorBody.message : `TreeDX request failed with status ${response.status}.`,
+        {
+          status: response.status,
+          code: typeof errorBody.code === "string" ? errorBody.code : "treedx_api_error",
+          details: isRecord(errorBody.details) ? errorBody.details : {},
+          payload
+        }
+      );
+    }
+    return stripOk(payload);
+  }
+  async requestBinary(path, body, options = {}) {
+    if (options.tokenRequired && !this.token) {
+      throw new TreeDxApiError("TreeDX bearer token is required.", {
+        status: 401,
+        code: "missing_token"
+      });
+    }
+    const response = await this.fetchWithTimeout(`${this.baseUrl}${path}${this.query({ ...options.query, download: true })}`, {
+      method: "POST",
+      headers: this.headers(true),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      let payload;
+      try {
+        payload = await response.json();
+      } catch {
+        payload = void 0;
+      }
+      const errorBody = isRecord(payload) && isRecord(payload.error) ? payload.error : {};
+      throw new TreeDxApiError(
+        typeof errorBody.message === "string" ? errorBody.message : `TreeDX request failed with status ${response.status}.`,
+        {
+          status: response.status,
+          code: typeof errorBody.code === "string" ? errorBody.code : "treedx_api_error",
+          details: isRecord(errorBody.details) ? errorBody.details : {},
+          payload
+        }
+      );
+    }
+    const content = await response.arrayBuffer();
+    const contentDisposition = response.headers.get("content-disposition");
+    return {
+      content,
+      contentType: response.headers.get("content-type"),
+      filename: parseFilename(contentDisposition),
+      checksum: response.headers.get("x-treedx-artifact-checksum") ?? void 0,
+      snapshotId: response.headers.get("x-treedx-snapshot-id") ?? void 0
+    };
+  }
+  async requestBlobDownload(input) {
+    if (!this.token) {
+      throw new TreeDxApiError("TreeDX bearer token is required.", {
+        status: 401,
+        code: "missing_token"
+      });
+    }
+    const response = await this.fetchWithTimeout(
+      `${this.baseUrl}/api/v1/workspaces/${encodeURIComponent(input.workspaceId)}/blobs/download${this.query({
+        path: input.path,
+        allowProtected: input.allowProtected
+      })}`,
+      {
+        method: "GET",
+        headers: this.headers(false)
+      }
+    );
+    await this.assertBinaryOk(response);
+    return {
+      content: await response.arrayBuffer(),
+      contentType: response.headers.get("content-type"),
+      contentHash: response.headers.get("x-treedx-content-hash") ?? void 0,
+      objectId: response.headers.get("x-treedx-object-id") ?? void 0,
+      source: response.headers.get("x-treedx-source")
+    };
+  }
+  async requestBlobUpload(input) {
+    if (!this.token) {
+      throw new TreeDxApiError("TreeDX bearer token is required.", {
+        status: 401,
+        code: "missing_token"
+      });
+    }
+    const headers = {
+      accept: "application/json",
+      "content-type": input.contentType ?? "application/octet-stream"
+    };
+    if (this.token) {
+      headers.authorization = `Bearer ${this.token}`;
+    }
+    if (input.expectedSha) {
+      headers["x-treedx-expected-sha"] = input.expectedSha;
+    }
+    if (input.expectedContentHash) {
+      headers["x-treedx-expected-content-hash"] = input.expectedContentHash;
+    }
+    if (input.allowProtected !== void 0) {
+      headers["x-treedx-allow-protected"] = String(input.allowProtected);
+    }
+    const response = await this.fetchWithTimeout(
+      `${this.baseUrl}/api/v1/workspaces/${encodeURIComponent(input.workspaceId)}/blobs/upload${this.query({
+        path: input.path
+      })}`,
+      {
+        method: "PUT",
+        headers,
+        body: input.content
+      }
+    );
+    const payload = await this.parseJsonResponse(response);
+    if (!response.ok || isRecord(payload) && payload.ok === false) {
+      this.throwApiError(response, payload);
+    }
+    return firstPayload(payload, ["result"]);
+  }
+  async assertBinaryOk(response) {
+    if (response.ok) {
+      return;
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      payload = void 0;
+    }
+    this.throwApiError(response, payload);
+  }
+  async parseJsonResponse(response) {
+    try {
+      return await response.json();
+    } catch (error) {
+      throw new TreeDxApiError("TreeDX response was not valid JSON.", {
+        status: response.status,
+        code: "invalid_response",
+        payload: error
+      });
+    }
+  }
+  throwApiError(response, payload) {
+    const errorBody = isRecord(payload) && isRecord(payload.error) ? payload.error : {};
+    throw new TreeDxApiError(
+      typeof errorBody.message === "string" ? errorBody.message : `TreeDX request failed with status ${response.status}.`,
+      {
+        status: response.status,
+        code: typeof errorBody.code === "string" ? errorBody.code : "treedx_api_error",
+        details: isRecord(errorBody.details) ? errorBody.details : {},
+        payload
+      }
+    );
+  }
+  health() {
+    return this.request("GET", "/api/v1/health");
+  }
+  ready() {
+    return this.request("GET", "/api/v1/ready").then((payload) => firstPayload(payload, ["readiness"]));
+  }
+  deepHealth(input = {}) {
+    return this.request(
+      "GET",
+      input.admin ? "/api/v1/admin/health/deep" : "/api/v1/health/deep",
+      void 0,
+      { tokenRequired: input.admin === true }
+    ).then((payload) => firstPayload(payload, ["health"]));
+  }
+  metrics() {
+    return this.request("GET", "/api/v1/metrics").then((payload) => firstPayload(payload, ["metrics"]));
+  }
+  async prometheusMetrics() {
+    const response = await this.fetchWithTimeout(`${this.baseUrl}/metrics`, {
+      method: "GET",
+      headers: { accept: "text/plain" }
+    });
+    if (!response.ok) {
+      let payload;
+      try {
+        payload = await response.json();
+      } catch {
+        payload = void 0;
+      }
+      this.throwApiError(response, payload);
+    }
+    return response.text();
+  }
+  whoami() {
+    return this.request("GET", "/api/v1/auth/whoami");
+  }
+  authMode() {
+    return this.request("GET", "/api/v1/auth/mode");
+  }
+  effectiveScope(input = {}) {
+    return this.request("GET", "/api/v1/policy/effective-scope", void 0, {
+      query: { repoId: input.repoId },
+      tokenRequired: true
+    });
+  }
+  listCapabilities() {
+    return this.request("GET", "/api/v1/policy/capabilities", void 0, { tokenRequired: true });
+  }
+  listCapabilityGrants(input = {}) {
+    return this.request("GET", "/api/v1/policy/grants", void 0, {
+      query: input,
+      tokenRequired: true
+    }).then((payload) => firstPayload(payload, ["grants"]));
+  }
+  putCapabilityGrant(input) {
+    return this.request("POST", "/api/v1/policy/grants", input, { tokenRequired: true }).then((payload) => firstPayload(payload, ["grant"]));
+  }
+  listAuditEvents(input = {}) {
+    return this.request(
+      "GET",
+      "/api/v1/audit/events",
+      void 0,
+      { query: input, tokenRequired: true }
+    );
+  }
+  planFederatedQuery(input) {
+    return this.request("POST", "/api/v1/federation/query/plan", input, { tokenRequired: true });
+  }
+  buildSnapshot(input = {}) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/snapshots/build`, body, { tokenRequired: true }).then((payload) => firstPayload(payload, ["snapshot"]));
+  }
+  getSnapshot(input) {
+    return this.request(
+      "GET",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(input.repoId))}/snapshots/${encodeURIComponent(input.snapshotId)}`,
+      void 0,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["snapshot"]));
+  }
+  exportArtifact(input = {}) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/artifacts/export`, body, { tokenRequired: true }).then((payload) => firstPayload(payload, ["artifact"]));
+  }
+  downloadArtifact(input = {}) {
+    const { repoId, ...body } = input;
+    return this.requestBinary(`/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/artifacts/export`, body, {
+      tokenRequired: true
+    });
+  }
+  syncMirror(input) {
+    const { repoId, mirrorId, ...body } = input;
+    return this.request(
+      "POST",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/mirrors/${encodeURIComponent(mirrorId)}/sync`,
+      body,
+      { tokenRequired: true }
+    );
+  }
+  fetchRemote(input) {
+    const { repoId, ...body } = input;
+    return this.request(
+      "POST",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/sync`,
+      body,
+      { tokenRequired: true }
+    );
+  }
+  push(input) {
+    const { repoId, ...body } = input;
+    return this.request(
+      "POST",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/push`,
+      body,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["push"]));
+  }
+  checkMirrorHealth(input) {
+    const { repoId, mirrorId } = input;
+    return this.request(
+      "POST",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/mirrors/${encodeURIComponent(mirrorId)}/health`,
+      {},
+      { tokenRequired: true }
+    );
+  }
+  promoteMirror(input) {
+    const { repoId, mirrorId, ...body } = input;
+    return this.request(
+      "POST",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/mirrors/${encodeURIComponent(mirrorId)}/promote`,
+      body,
+      { tokenRequired: true }
+    );
+  }
+  compactStorage(input = {}) {
+    return this.request("POST", "/api/v1/admin/storage/compact", input, {
+      tokenRequired: true
+    });
+  }
+  backupStorage(input = {}) {
+    return this.request("POST", "/api/v1/admin/storage/backup", input, {
+      tokenRequired: true
+    });
+  }
+  listStorageMigrations() {
+    return this.request(
+      "GET",
+      "/api/v1/admin/storage/migrations",
+      void 0,
+      { tokenRequired: true }
+    );
+  }
+  planStorageMigration(input = {}) {
+    return this.request(
+      "POST",
+      "/api/v1/admin/storage/migrations/plan",
+      input,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["migration"]));
+  }
+  applyStorageMigration(input = {}) {
+    return this.request(
+      "POST",
+      "/api/v1/admin/storage/migrations/apply",
+      input,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["migration"]));
+  }
+  rollbackStorageMigration(input) {
+    return this.request(
+      "POST",
+      "/api/v1/admin/storage/migrations/rollback",
+      input,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["migration"]));
+  }
+  verifyStorageRestore(input) {
+    return this.request(
+      "POST",
+      "/api/v1/admin/storage/restore/verify",
+      input,
+      { tokenRequired: true }
+    ).then((payload) => payload.restore);
+  }
+  restoreStorage(input) {
+    return this.request(
+      "POST",
+      "/api/v1/admin/storage/restore",
+      input,
+      { tokenRequired: true }
+    ).then((payload) => payload.restore);
+  }
+  createMigration(input) {
+    const { repoId, ...body } = input;
+    return this.request(
+      "POST",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/migrations`,
+      body,
+      { tokenRequired: true }
+    );
+  }
+  getMigration(input) {
+    return this.request(
+      "GET",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(input.repoId))}/migrations/${encodeURIComponent(input.migrationId)}`,
+      void 0,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["migration"]));
+  }
+  getNode() {
+    return this.request("GET", "/api/v1/node", void 0, { tokenRequired: true }).then((payload) => firstPayload(payload, ["node"]));
+  }
+  listNodes() {
+    return this.request("GET", "/api/v1/registry/nodes", void 0, { tokenRequired: true }).then((payload) => firstPayload(payload, ["nodes"]));
+  }
+  getPlacement(repoId) {
+    return this.request("GET", `/api/v1/registry/repos/${encodeURIComponent(repoId)}/placement`, void 0, { tokenRequired: true }).then((payload) => firstPayload(payload, ["placement"]));
+  }
+  getRepository(repoId) {
+    return this.request("GET", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}`, void 0, { tokenRequired: true }).then((payload) => firstPayload(payload, ["repo"]));
+  }
+  createWorkspace(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/workspaces`, body, { tokenRequired: true });
+  }
+  async closeWorkspace(workspaceId) {
+    await this.request("POST", `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/close`, {}, { tokenRequired: true });
+  }
+  listTree(input) {
+    return this.request("GET", `/api/v1/workspaces/${encodeURIComponent(input.workspaceId)}/tree`, void 0, {
+      query: { path: input.path ?? "", includeDeleted: input.includeDeleted },
+      tokenRequired: true
+    }).then((payload) => firstPayload(payload, ["entries"]));
+  }
+  readFile(input) {
+    return this.request("GET", `/api/v1/workspaces/${encodeURIComponent(input.workspaceId)}/files`, void 0, {
+      query: { path: input.path, allowProtected: input.allowProtected },
+      tokenRequired: true
+    });
+  }
+  writeFile(input) {
+    const { workspaceId, path, ...body } = input;
+    return this.request("PUT", `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/files`, body, {
+      query: { path },
+      tokenRequired: true
+    });
+  }
+  patchFile(input) {
+    const { workspaceId, path, ...body } = input;
+    return this.request("PATCH", `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/files`, body, {
+      query: { path },
+      tokenRequired: true
+    });
+  }
+  deleteFile(input) {
+    const { workspaceId, path, ...body } = input;
+    return this.request("DELETE", `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/files`, body, {
+      query: { path },
+      tokenRequired: true
+    });
+  }
+  readBlob(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/blobs/read`, body, {
+      tokenRequired: true
+    }).then((payload) => firstPayload(payload, ["blob"]));
+  }
+  writeBlob(input) {
+    const { workspaceId, path, ...body } = input;
+    return this.request(
+      "POST",
+      `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/blobs/write`,
+      { path, ...body, encoding: body.encoding ?? "base64" },
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["result"]));
+  }
+  deleteBlob(input) {
+    const { workspaceId, ...body } = input;
+    return this.request(
+      "POST",
+      `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/blobs/delete`,
+      body,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["result"]));
+  }
+  downloadBlob(input) {
+    return this.requestBlobDownload(input);
+  }
+  uploadBlob(input) {
+    return this.requestBlobUpload(input);
+  }
+  createBlobUpload(input) {
+    const { workspaceId, ...body } = input;
+    return this.request(
+      "POST",
+      `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/blobs/uploads`,
+      body,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["upload"]));
+  }
+  async uploadBlobPart(input) {
+    if (!this.token) {
+      throw new TreeDxApiError("TreeDX bearer token is required.", {
+        status: 401,
+        code: "missing_token"
+      });
+    }
+    const response = await this.fetchWithTimeout(
+      `${this.baseUrl}/api/v1/workspaces/${encodeURIComponent(input.workspaceId)}/blobs/uploads/${encodeURIComponent(input.uploadId)}/parts/${encodeURIComponent(input.partNumber)}`,
+      {
+        method: "PUT",
+        headers: {
+          accept: "application/json",
+          authorization: `Bearer ${this.token}`,
+          "content-type": "application/octet-stream"
+        },
+        body: input.content
+      }
+    );
+    const payload = await this.parseJsonResponse(response);
+    if (!response.ok || isRecord(payload) && payload.ok === false) {
+      this.throwApiError(response, payload);
+    }
+    return firstPayload(payload, ["part"]);
+  }
+  completeBlobUpload(input) {
+    const { workspaceId, uploadId, ...body } = input;
+    return this.request(
+      "POST",
+      `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/blobs/uploads/${encodeURIComponent(uploadId)}/complete`,
+      body,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["result"]));
+  }
+  abortBlobUpload(input) {
+    return this.request(
+      "DELETE",
+      `/api/v1/workspaces/${encodeURIComponent(input.workspaceId)}/blobs/uploads/${encodeURIComponent(input.uploadId)}`,
+      void 0,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["upload"]));
+  }
+  listArtifacts(input = {}) {
+    return this.request(
+      "GET",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(input.repoId))}/artifacts`,
+      void 0,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["artifacts"]));
+  }
+  getArtifact(input) {
+    return this.request(
+      "GET",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(input.repoId))}/artifacts/${encodeURIComponent(input.artifactId)}`,
+      void 0,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["artifact"]));
+  }
+  deleteArtifact(input) {
+    return this.request(
+      "DELETE",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(input.repoId))}/artifacts/${encodeURIComponent(input.artifactId)}`,
+      void 0,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["artifact"]));
+  }
+  cleanupArtifacts(input = {}) {
+    return this.request(
+      "POST",
+      "/api/v1/admin/artifacts/cleanup",
+      input,
+      { tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["cleanup"]));
+  }
+  search(input) {
+    const { workspaceId, ...body } = input;
+    return this.request("POST", `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/search`, body, { tokenRequired: true });
+  }
+  status(input) {
+    return this.request("GET", `/api/v1/workspaces/${encodeURIComponent(input.workspaceId)}/status`, void 0, { tokenRequired: true });
+  }
+  diff(input) {
+    return this.request("GET", `/api/v1/workspaces/${encodeURIComponent(input.workspaceId)}/diff`, void 0, { tokenRequired: true });
+  }
+  commit(input) {
+    const { workspaceId, ...body } = input;
+    return this.request("POST", `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/commit`, body, { tokenRequired: true });
+  }
+  exec(input) {
+    const { workspaceId, ...body } = input;
+    return this.request("POST", `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/exec`, body, { tokenRequired: true });
+  }
+  readRepositoryFiles(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/files/read`, body, { tokenRequired: true });
+  }
+  readRepositoryFile(input) {
+    return this.readRepositoryFiles(input);
+  }
+  listRepositoryPaths(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/paths/list`, body, { tokenRequired: true });
+  }
+  searchRepositoryFiles(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/files/search`, body, { tokenRequired: true });
+  }
+  queryRepository(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/query`, body, { tokenRequired: true });
+  }
+  federatedSearch(input) {
+    return this.request("POST", "/api/v1/search", input, { tokenRequired: true }).then((payload) => firstPayload(payload, ["search"]));
+  }
+  federatedQuery(input) {
+    return this.request("POST", "/api/v1/query", input, { tokenRequired: true }).then((payload) => firstPayload(payload, ["query"]));
+  }
+  federatedContext(input) {
+    return this.request("POST", "/api/v1/context/build", input, { tokenRequired: true }).then((payload) => firstPayload(payload, ["context"]));
+  }
+  federatedGraph(input) {
+    return this.request("POST", "/api/v1/graph/query", input, { tokenRequired: true }).then((payload) => firstPayload(payload, ["graph"]));
+  }
+  refreshGraph(input = {}) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/graph/refresh`, body, { tokenRequired: true });
+  }
+  getGraphRefreshJob(input) {
+    return this.request(
+      "GET",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(input.repoId))}/graph/refresh-jobs/${encodeURIComponent(input.jobId)}`,
+      void 0,
+      { query: { ref: input.ref }, tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["job"]));
+  }
+  refreshSearchIndex(input = {}) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/search/index/refresh`, body, { tokenRequired: true }).then((payload) => firstPayload(payload, ["index"]));
+  }
+  getSearchIndexStatus(input = {}) {
+    return this.request(
+      "GET",
+      `/api/v1/repos/${encodeURIComponent(this.repoId(input.repoId))}/search/index/status`,
+      void 0,
+      { query: { ref: input.ref }, tokenRequired: true }
+    ).then((payload) => firstPayload(payload, ["index"]));
+  }
+  compactSearchIndex(input = {}) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/search/index/compact`, body, { tokenRequired: true }).then((payload) => firstPayload(payload, ["compact"]));
+  }
+  queryGraph(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/graph/query`, body, { tokenRequired: true });
+  }
+  searchGraphFiles(input) {
+    return this.graphSearch("/graph/search-files", input);
+  }
+  searchGraphSections(input) {
+    return this.graphSearch("/graph/search-sections", input);
+  }
+  searchGraphEntities(input) {
+    return this.graphSearch("/graph/search-entities", input);
+  }
+  getGraphNode(input) {
+    return this.request("GET", `/api/v1/repos/${encodeURIComponent(this.repoId(input.repoId))}/graph/nodes/${encodeURIComponent(input.nodeId)}`, void 0, {
+      query: { ref: input.ref },
+      tokenRequired: true
+    }).then((payload) => firstPayload(payload, ["node"]));
+  }
+  getRelated(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/graph/related`, body, { tokenRequired: true });
+  }
+  getSubgraph(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/graph/subgraph`, body, { tokenRequired: true });
+  }
+  buildContext(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/context/build`, body, { tokenRequired: true });
+  }
+  parseContextDsl(input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/context/parse-ctx`, body, { tokenRequired: true });
+  }
+  graphSearch(path, input) {
+    const { repoId, ...body } = input;
+    return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}${path}`, body, { tokenRequired: true }).then((payload) => firstPayload(payload, ["results"]));
+  }
+}
+function parseFilename(contentDisposition) {
+  if (!contentDisposition) {
+    return void 0;
+  }
+  const match = /filename="([^"]+)"/u.exec(contentDisposition) ?? /filename=([^;]+)/u.exec(contentDisposition);
+  return match?.[1];
+}
+export {
+  TREEDX_CLIENT_OPERATION_MAP,
+  TreeDxClient
+};