@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/treedx/client/treedx/search/contracts/federated-search.js

@@ -0,0 +1,7 @@
+import { firstPayload } from "../../../../support/client.js";
+function federatedSearchMethod(input) {
+  return this.request("POST", "/api/v1/search", input, { tokenRequired: true }).then((payload) => firstPayload(payload, ["search"]));
+}
+export {
+  federatedSearchMethod
+};

package/dist/treedx/client/treedx/workspaces/creation/create-workspace.d.ts

@@ -0,0 +1,3 @@
+import { TreeDxClient } from "../../../../support/client.js";
+import type { TreeDxCreateWorkspaceRequest, TreeDxWorkspace } from "../../../../types.js";
+export declare function createWorkspaceMethod(this: TreeDxClient, input: TreeDxCreateWorkspaceRequest): Promise<TreeDxWorkspace>;

package/dist/treedx/client/treedx/workspaces/creation/create-workspace.js

@@ -0,0 +1,7 @@
+function createWorkspaceMethod(input) {
+  const { repoId, ...body } = input;
+  return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/workspaces`, body, { tokenRequired: true });
+}
+export {
+  createWorkspaceMethod
+};

package/dist/treedx/client/treedx/workspaces/retirement/abandon-workspace.d.ts

@@ -0,0 +1,3 @@
+import { TreeDxClient } from '../../../../support/client.js';
+import type { TreeDxWorkspaceAbandonResult } from '../../../../types.js';
+export declare function abandonWorkspaceMethod(this: TreeDxClient, workspaceId: string, expectedHead: string): Promise<TreeDxWorkspaceAbandonResult>;

package/dist/treedx/client/treedx/workspaces/retirement/abandon-workspace.js

@@ -0,0 +1,12 @@
+import { firstPayload } from "../../../../support/client.js";
+function abandonWorkspaceMethod(workspaceId, expectedHead) {
+  return this.request(
+    "POST",
+    `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/abandon`,
+    { expectedHead },
+    { tokenRequired: true }
+  ).then((payload) => firstPayload(payload, ["payload"]));
+}
+export {
+  abandonWorkspaceMethod
+};

package/dist/treedx/client/treedx/workspaces/retirement/close-workspace.d.ts

@@ -0,0 +1,2 @@
+import { TreeDxClient } from "../../../../support/client.js";
+export declare function closeWorkspaceMethod(this: TreeDxClient, workspaceId: string): Promise<void>;

package/dist/treedx/client/treedx/workspaces/retirement/close-workspace.js

@@ -0,0 +1,6 @@
+async function closeWorkspaceMethod(workspaceId) {
+  await this.request("POST", `/api/v1/workspaces/${encodeURIComponent(workspaceId)}/close`, {}, { tokenRequired: true });
+}
+export {
+  closeWorkspaceMethod
+};

package/dist/treedx/generated/openapi-types.d.ts

@@ -232,6 +232,15 @@ export interface paths {
     "/api/v1/repos/{repo_id}/refs": {
         get: operations['listRepositoryRefs'];
     };
+    "/api/v1/repos/{repo_id}/refs/discard-orphan": {
+        post: operations['discardOrphanRepositoryRef'];
+    };
+    "/api/v1/repos/{repo_id}/refs/promote": {
+        post: operations['promoteRepositoryRef'];
+    };
+    "/api/v1/repos/{repo_id}/refs/retire": {
+        post: operations['retireRepositoryRef'];
+    };
     "/api/v1/repos/{repo_id}/remotes": {
         get: operations['listRepositoryRemotes'];
     };
@@ -645,6 +654,10 @@ export interface components {
             changedPaths?: string[];
             [key: string]: unknown;
         };
+        TreeDxDiscardOrphanRepositoryRefResponse: {
+            ok: true;
+            discard: components['schemas']['TreeDxOrphanRefDiscardResult'];
+        };
         TreeDxEffectiveScope: {
             actorId: string;
             tenantIds?: string[];
@@ -1335,6 +1348,17 @@ export interface components {
         TreeDxOkEnvelope: {
             ok: true;
         };
+        TreeDxOrphanRefDiscardRequest: {
+            ref: string;
+            expectedHead: string;
+            reason: string;
+        };
+        TreeDxOrphanRefDiscardResult: {
+            repoId: string;
+            ref: string;
+            head: string;
+            status: string;
+        };
         TreeDxParseContextQueryResponse: {
             ok: true;
             parse?: components['schemas']['TreeDxCtxParseResult'];
@@ -1391,6 +1415,10 @@ export interface components {
             promotion?: components['schemas']['TreeDxMirrorPromotionResult'];
             [key: string]: unknown;
         };
+        TreeDxPromoteRepositoryRefResponse: {
+            ok: true;
+            promotion: components['schemas']['TreeDxRefPromotionResult'];
+        };
         TreeDxPushRepositoryResponse: {
             ok: true;
             push?: components['schemas']['TreeDxPushResult'];
@@ -1472,6 +1500,19 @@ export interface components {
             [key: string]: unknown;
         };
         TreeDxRefName: string;
+        TreeDxRefPromotionRequest: {
+            sourceRef: string;
+            destinationRef: string;
+            expectedDestinationHead: string;
+        };
+        TreeDxRefPromotionResult: {
+            repoId: string;
+            sourceRef: string;
+            destinationRef: string;
+            beforeHead: string;
+            afterHead: string;
+            status: string;
+        };
         TreeDxRefreshPolicyResponse: {
             ok: true;
             policy?: components['schemas']['TreeDxPolicyRefreshResult'];
@@ -1487,6 +1528,20 @@ export interface components {
             index?: components['schemas']['TreeDxSearchIndexRefreshResult'];
             [key: string]: unknown;
         };
+        TreeDxRefRetirementRequest: {
+            ref: string;
+            mergedIntoRef: string;
+            expectedHead: string;
+            expectedMergedIntoHead: string;
+        };
+        TreeDxRefRetirementResult: {
+            repoId: string;
+            ref: string;
+            mergedIntoRef: string;
+            head: string;
+            mergedIntoHead: string;
+            status: string;
+        };
         TreeDxRegisterRepositoryRequest: {
             repositoryName: components['schemas']['TreeDxRepositoryName'];
             name?: components['schemas']['TreeDxRepositoryName'];
@@ -1600,6 +1655,10 @@ export interface components {
             restore?: components['schemas']['TreeDxStorageRestoreResult'];
             [key: string]: unknown;
         };
+        TreeDxRetireRepositoryRefResponse: {
+            ok: true;
+            retirement: components['schemas']['TreeDxRefRetirementResult'];
+        };
         TreeDxRollbackStorageMigrationResponse: {
             ok: true;
             migration?: components['schemas']['TreeDxStorageMigration'];
@@ -2148,6 +2207,21 @@ export interface operations {
             "503": components['schemas']['TreeDxErrorEnvelope'];
         };
     };
+    discardOrphanRepositoryRef: {
+        parameters: {
+            path: never;
+            query: never;
+            header: never;
+        };
+        requestBody: components['schemas']['TreeDxOrphanRefDiscardRequest'];
+        responses: {
+            "200": components['schemas']['TreeDxDiscardOrphanRepositoryRefResponse'];
+            "401": components['schemas']['TreeDxErrorEnvelope'];
+            "403": components['schemas']['TreeDxErrorEnvelope'];
+            "409": components['schemas']['TreeDxErrorEnvelope'];
+            "422": components['schemas']['TreeDxErrorEnvelope'];
+        };
+    };
     downloadWorkspaceBlob: {
         parameters: {
             path: never;
@@ -3023,6 +3097,21 @@ export interface operations {
             "503": components['schemas']['TreeDxErrorEnvelope'];
         };
     };
+    promoteRepositoryRef: {
+        parameters: {
+            path: never;
+            query: never;
+            header: never;
+        };
+        requestBody: components['schemas']['TreeDxRefPromotionRequest'];
+        responses: {
+            "200": components['schemas']['TreeDxPromoteRepositoryRefResponse'];
+            "401": components['schemas']['TreeDxErrorEnvelope'];
+            "403": components['schemas']['TreeDxErrorEnvelope'];
+            "409": components['schemas']['TreeDxErrorEnvelope'];
+            "422": components['schemas']['TreeDxErrorEnvelope'];
+        };
+    };
     proxyInternalFederationRequest: {
         parameters: {
             path: never;
@@ -3299,6 +3388,21 @@ export interface operations {
             "503": components['schemas']['TreeDxErrorEnvelope'];
         };
     };
+    retireRepositoryRef: {
+        parameters: {
+            path: never;
+            query: never;
+            header: never;
+        };
+        requestBody: components['schemas']['TreeDxRefRetirementRequest'];
+        responses: {
+            "200": components['schemas']['TreeDxRetireRepositoryRefResponse'];
+            "401": components['schemas']['TreeDxErrorEnvelope'];
+            "403": components['schemas']['TreeDxErrorEnvelope'];
+            "409": components['schemas']['TreeDxErrorEnvelope'];
+            "422": components['schemas']['TreeDxErrorEnvelope'];
+        };
+    };
     revokeFederationPeer: {
         parameters: {
             path: {

package/dist/treedx/support/client.d.ts

@@ -0,0 +1,251 @@
+import type { TreeDxChangesetReceipt, TreeDxChangesetRequest, TreeDxWriteFilesRequest, TreeDxWriteFilesResult } from '../types.js';
+import type { SdkGraphSearchResult, TreeDxArtifact, TreeDxArtifactCleanupRequest, TreeDxArtifactCleanupResult, TreeDxArtifactDeleteRequest, TreeDxArtifactDownload, TreeDxArtifactExportRequest, TreeDxArtifactGetRequest, TreeDxArtifactListRequest, TreeDxAuditEvent, TreeDxAuthMode, TreeDxBlob, TreeDxBlobDeleteRequest, TreeDxBlobDownload, TreeDxBlobDownloadRequest, TreeDxBlobMutationResult, TreeDxBlobReadRequest, TreeDxBlobUploadAbortRequest, TreeDxBlobUploadCompleteRequest, TreeDxBlobUploadCreateRequest, TreeDxBlobUploadPart, TreeDxBlobUploadPartRequest, TreeDxBlobUploadRequest, TreeDxBlobUploadSession, TreeDxBlobWriteRequest, TreeDxCapabilityGrant, TreeDxClientOptions, TreeDxCommitRequest, TreeDxCommitResult, TreeDxContextRequest, TreeDxContextResult, TreeDxCreateWorkspaceRequest, TreeDxCtxParseRequest, TreeDxCtxParseResult, TreeDxDeepHealth, TreeDxDeleteFileRequest, TreeDxDiff, TreeDxEffectiveScope, TreeDxEffectiveScopeRequest, TreeDxExecRequest, TreeDxExecResult, TreeDxFederatedContextRequest, TreeDxFederatedContextResult, TreeDxFederatedGraphRequest, TreeDxFederatedGraphResult, TreeDxFederatedQueryRequest, TreeDxFederatedQueryResult, TreeDxFederatedSearchRequest, TreeDxFederatedSearchResult, TreeDxFederationQueryPlan, TreeDxFederationQueryPlanRequest, TreeDxFetchRemoteRequest, TreeDxFetchRemoteResult, TreeDxFile, TreeDxFileMutationResult, TreeDxGraphNodeRequest, TreeDxGraphQueryRequest, TreeDxGraphQueryResult, TreeDxGraphRefreshJob, TreeDxGraphRefreshJobRequest, TreeDxGraphRefreshRequest, TreeDxGraphRefreshResult, TreeDxGraphRelatedRequest, TreeDxGraphSearchRequest, TreeDxGraphSubgraphRequest, TreeDxHealth, TreeDxListTreeRequest, TreeDxMetrics, TreeDxMigration, TreeDxMigrationRequest, TreeDxMirrorHealthRequest, TreeDxMirrorHealthResult, TreeDxMirrorPromotionRequest, TreeDxMirrorPromotionResult, TreeDxMirrorSyncRequest, TreeDxMirrorSyncResult, TreeDxNode, TreeDxOrphanRefDiscardRequest, TreeDxOrphanRefDiscardResult, TreeDxPatchFileRequest, TreeDxPushRequest, TreeDxPushResult, TreeDxReadFileRequest, TreeDxReadiness, TreeDxRef, TreeDxRefPromotionRequest, TreeDxRefPromotionResult, TreeDxRefRetirementRequest, TreeDxRefRetirementResult, TreeDxRegisterRepositoryRequest, TreeDxRepository, TreeDxRepositoryPathsRequest, TreeDxRepositoryPlacement, TreeDxRepositoryQueryRequest, TreeDxRepositoryQueryResult, TreeDxRepositoryReadRequest, TreeDxRepositorySearchRequest, TreeDxSearchIndexCompactRequest, TreeDxSearchIndexCompactResult, TreeDxSearchIndexRefreshRequest, TreeDxSearchIndexRefreshResult, TreeDxSearchIndexStatus, TreeDxSearchIndexStatusRequest, TreeDxSearchRequest, TreeDxSearchResult, TreeDxSnapshot, TreeDxSnapshotBuildRequest, TreeDxStatus, TreeDxStorageBackupRequest, TreeDxStorageBackupResult, TreeDxStorageCompactRequest, TreeDxStorageCompactResult, TreeDxStorageMigration, TreeDxStorageMigrationPlanRequest, TreeDxStorageMigrationRollbackRequest, TreeDxStorageRestoreRequest, TreeDxStorageRestoreResult, TreeDxStorageRestoreVerifyRequest, TreeDxTreeEntry, TreeDxWhoami, TreeDxWorkspace, TreeDxWorkspaceAbandonResult, TreeDxWorkspaceRequest, TreeDxWriteFileRequest } from '../types.js';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export declare function normalizeBaseUrl(baseUrl: string): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isAbortError(error: unknown): boolean;
+export declare function stripOk<T>(payload: unknown): T;
+export declare function firstPayload<T>(payload: unknown, keys: string[]): T;
+export declare const TREEDX_CLIENT_OPERATION_MAP: {
+    readonly health: "getHealth";
+    readonly ready: "getReadiness";
+    readonly deepHealth: "getDeepHealth";
+    readonly adminDeepHealth: "getAdminDeepHealth";
+    readonly metrics: "getMetrics";
+    readonly prometheusMetrics: "getPrometheusMetrics";
+    readonly whoami: "getWhoami";
+    readonly authMode: "getAuthMode";
+    readonly effectiveScope: "getEffectiveScope";
+    readonly listCapabilities: "listCapabilities";
+    readonly listCapabilityGrants: "listCapabilityGrants";
+    readonly putCapabilityGrant: "putCapabilityGrant";
+    readonly listAuditEvents: "listAuditEvents";
+    readonly planFederatedQuery: "planFederationQuery";
+    readonly buildSnapshot: "buildSnapshot";
+    readonly getSnapshot: "getSnapshot";
+    readonly exportArtifact: "exportArtifact";
+    readonly syncMirror: "syncMirror";
+    readonly fetchRemote: "syncRepository";
+    readonly push: "pushRepository";
+    readonly promoteRef: "promoteRepositoryRef";
+    readonly retireRef: "retireRepositoryRef";
+    readonly discardOrphanRef: "discardOrphanRepositoryRef";
+    readonly checkMirrorHealth: "checkMirrorHealth";
+    readonly promoteMirror: "promoteMirror";
+    readonly compactStorage: "compactAdminStorage";
+    readonly backupStorage: "backupAdminStorage";
+    readonly listStorageMigrations: "listStorageMigrations";
+    readonly planStorageMigration: "planStorageMigration";
+    readonly applyStorageMigration: "applyStorageMigration";
+    readonly rollbackStorageMigration: "rollbackStorageMigration";
+    readonly verifyStorageRestore: "verifyStorageRestore";
+    readonly restoreStorage: "restoreStorage";
+    readonly createMigration: "createMigration";
+    readonly getMigration: "getMigration";
+    readonly getNode: "getLocalNode";
+    readonly listNodes: "listRegistryNodes";
+    readonly getPlacement: "getRepositoryPlacement";
+    readonly getRepository: "getRepository";
+    readonly createWorkspace: "createWorkspace";
+    readonly closeWorkspace: "closeWorkspace";
+    readonly listTree: "listWorkspaceTree";
+    readonly readFile: "readWorkspaceFile";
+    readonly writeFile: "writeWorkspaceFile";
+    readonly patchFile: "patchWorkspaceFile";
+    readonly deleteFile: "deleteWorkspaceFile";
+    readonly readBlob: "readRepositoryBlob";
+    readonly writeBlob: "writeWorkspaceBlob";
+    readonly deleteBlob: "deleteWorkspaceBlob";
+    readonly downloadBlob: "downloadWorkspaceBlob";
+    readonly uploadBlob: "uploadWorkspaceBlob";
+    readonly createBlobUpload: "createWorkspaceBlobUpload";
+    readonly uploadBlobPart: "uploadWorkspaceBlobPart";
+    readonly completeBlobUpload: "completeWorkspaceBlobUpload";
+    readonly abortBlobUpload: "abortWorkspaceBlobUpload";
+    readonly listArtifacts: "listArtifacts";
+    readonly getArtifact: "getArtifact";
+    readonly deleteArtifact: "deleteArtifact";
+    readonly cleanupArtifacts: "cleanupArtifacts";
+    readonly search: "searchWorkspace";
+    readonly status: "getWorkspaceStatus";
+    readonly diff: "getWorkspaceDiff";
+    readonly commit: "commitWorkspace";
+    readonly exec: "execWorkspace";
+    readonly readRepositoryFiles: "readRepositoryFile";
+    readonly readRepositoryFile: "readRepositoryFile";
+    readonly listRepositoryPaths: "listRepositoryPaths";
+    readonly searchRepositoryFiles: "searchRepositoryFiles";
+    readonly queryRepository: "queryRepository";
+    readonly federatedSearch: "federatedSearch";
+    readonly federatedQuery: "federatedQuery";
+    readonly federatedContext: "federatedContextBuild";
+    readonly federatedGraph: "federatedGraphQuery";
+    readonly refreshGraph: "refreshRepositoryGraph";
+    readonly getGraphRefreshJob: "getGraphRefreshJob";
+    readonly refreshSearchIndex: "refreshSearchIndex";
+    readonly getSearchIndexStatus: "getSearchIndexStatus";
+    readonly compactSearchIndex: "compactSearchIndex";
+    readonly queryGraph: "queryRepositoryGraph";
+    readonly searchGraphFiles: "searchGraphFiles";
+    readonly searchGraphSections: "searchGraphSections";
+    readonly searchGraphEntities: "searchGraphEntities";
+    readonly getGraphNode: "getGraphNode";
+    readonly getRelated: "getRelatedGraphNodes";
+    readonly getSubgraph: "getGraphSubgraph";
+    readonly buildContext: "buildContext";
+    readonly parseContextDsl: "parseContextQuery";
+};
+export declare class TreeDxClient {
+    readonly options: TreeDxClientOptions;
+    readonly baseUrl: string;
+    readonly token?: string;
+    readonly defaultRepoId?: string;
+    readonly fetchImpl: typeof fetch;
+    constructor(options: TreeDxClientOptions);
+}
+export interface TreeDxClient {
+    repoId(inputRepoId?: string): any;
+    query(params?: Record<string, unknown>): any;
+    headers(bodyPresent: boolean): any;
+    fetchWithTimeout(input: string, init: RequestInit): Promise<Response>;
+    request<T>(method: HttpMethod, path: string, body?: unknown, options?: {
+        query?: Record<string, string | number | boolean | null | undefined>;
+        tokenRequired?: boolean;
+        gzipThresholdBytes?: number;
+    }): Promise<T>;
+    requestBinary(path: string, body: unknown, options?: {
+        query?: Record<string, string | number | boolean | null | undefined>;
+        tokenRequired?: boolean;
+    }): Promise<TreeDxArtifactDownload>;
+    requestBlobDownload(input: TreeDxBlobDownloadRequest): Promise<TreeDxBlobDownload>;
+    requestBlobUpload(input: TreeDxBlobUploadRequest): Promise<TreeDxBlobMutationResult>;
+    assertBinaryOk(response: Response): Promise<void>;
+    parseJsonResponse(response: Response): Promise<unknown>;
+    throwApiError(response: Response, payload: unknown): never;
+    health(): Promise<TreeDxHealth>;
+    ready(): Promise<TreeDxReadiness>;
+    deepHealth(input?: {
+        admin?: boolean;
+    }): Promise<TreeDxDeepHealth>;
+    metrics(): Promise<TreeDxMetrics>;
+    prometheusMetrics(): Promise<string>;
+    whoami(): Promise<TreeDxWhoami>;
+    authMode(): Promise<TreeDxAuthMode>;
+    effectiveScope(input?: TreeDxEffectiveScopeRequest): Promise<TreeDxEffectiveScope>;
+    listCapabilities(): Promise<{
+        capabilities: string[];
+    }>;
+    listCapabilityGrants(input?: {
+        actorId?: string;
+        repoId?: string;
+    }): Promise<TreeDxCapabilityGrant[]>;
+    putCapabilityGrant(input: TreeDxCapabilityGrant): Promise<TreeDxCapabilityGrant>;
+    listAuditEvents(input?: {
+        actorId?: string;
+        tenantId?: string;
+        repoId?: string;
+        eventType?: string;
+        limit?: number;
+    }): Promise<{
+        events: TreeDxAuditEvent[];
+        page: {
+            limit: number;
+            hasMore: boolean;
+        };
+    }>;
+    planFederatedQuery(input: TreeDxFederationQueryPlanRequest): Promise<TreeDxFederationQueryPlan>;
+    buildSnapshot(input?: TreeDxSnapshotBuildRequest): Promise<TreeDxSnapshot>;
+    getSnapshot(input: {
+        repoId?: string;
+        snapshotId: string;
+    }): Promise<TreeDxSnapshot>;
+    exportArtifact(input?: TreeDxArtifactExportRequest): Promise<TreeDxArtifact>;
+    downloadArtifact(input?: TreeDxArtifactExportRequest): Promise<TreeDxArtifactDownload>;
+    syncMirror(input: TreeDxMirrorSyncRequest): Promise<TreeDxMirrorSyncResult>;
+    fetchRemote(input: TreeDxFetchRemoteRequest): Promise<TreeDxFetchRemoteResult>;
+    push(input: TreeDxPushRequest): Promise<TreeDxPushResult>;
+    promoteRef(input: TreeDxRefPromotionRequest): Promise<TreeDxRefPromotionResult>;
+    retireRef(input: TreeDxRefRetirementRequest): Promise<TreeDxRefRetirementResult>;
+    discardOrphanRef(input: TreeDxOrphanRefDiscardRequest): Promise<TreeDxOrphanRefDiscardResult>;
+    listRepositoryRefs(repoId?: string): Promise<TreeDxRef[]>;
+    abandonWorkspace(workspaceId: string, expectedHead: string): Promise<TreeDxWorkspaceAbandonResult>;
+    checkMirrorHealth(input: TreeDxMirrorHealthRequest): Promise<TreeDxMirrorHealthResult>;
+    promoteMirror(input: TreeDxMirrorPromotionRequest): Promise<TreeDxMirrorPromotionResult>;
+    compactStorage(input?: TreeDxStorageCompactRequest): Promise<TreeDxStorageCompactResult>;
+    backupStorage(input?: TreeDxStorageBackupRequest): Promise<TreeDxStorageBackupResult>;
+    listStorageMigrations(): Promise<{
+        migrations: TreeDxStorageMigration[];
+        manifest: Record<string, unknown>;
+    }>;
+    planStorageMigration(input?: TreeDxStorageMigrationPlanRequest): Promise<TreeDxStorageMigration>;
+    applyStorageMigration(input?: TreeDxStorageMigrationPlanRequest): Promise<TreeDxStorageMigration>;
+    rollbackStorageMigration(input: TreeDxStorageMigrationRollbackRequest): Promise<TreeDxStorageMigration>;
+    verifyStorageRestore(input: TreeDxStorageRestoreVerifyRequest): Promise<TreeDxStorageRestoreResult['restore']>;
+    restoreStorage(input: TreeDxStorageRestoreRequest): Promise<TreeDxStorageRestoreResult['restore']>;
+    createMigration(input: TreeDxMigrationRequest): Promise<{
+        migration: TreeDxMigration;
+        placement?: TreeDxRepositoryPlacement;
+    }>;
+    getMigration(input: {
+        repoId?: string;
+        migrationId: string;
+    }): Promise<TreeDxMigration>;
+    getNode(): Promise<TreeDxNode>;
+    listNodes(): Promise<TreeDxNode[]>;
+    getPlacement(repoId: string): Promise<TreeDxRepositoryPlacement>;
+    getRepository(repoId?: string): Promise<TreeDxRepository>;
+    listRepositories(): Promise<TreeDxRepository[]>;
+    registerRepository(input: TreeDxRegisterRepositoryRequest): Promise<TreeDxRepository>;
+    createWorkspace(input: TreeDxCreateWorkspaceRequest): Promise<TreeDxWorkspace>;
+    closeWorkspace(workspaceId: string): Promise<void>;
+    listTree(input: TreeDxListTreeRequest): Promise<TreeDxTreeEntry[]>;
+    readFile(input: TreeDxReadFileRequest): Promise<TreeDxFile>;
+    writeFile(input: TreeDxWriteFileRequest): Promise<TreeDxFileMutationResult>;
+    writeFiles(input: TreeDxWriteFilesRequest): Promise<TreeDxWriteFilesResult>;
+    applyChangeset(input: TreeDxChangesetRequest): Promise<TreeDxChangesetReceipt>;
+    patchFile(input: TreeDxPatchFileRequest): Promise<TreeDxFileMutationResult>;
+    deleteFile(input: TreeDxDeleteFileRequest): Promise<TreeDxFileMutationResult>;
+    readBlob(input: TreeDxBlobReadRequest): Promise<TreeDxBlob>;
+    writeBlob(input: TreeDxBlobWriteRequest): Promise<TreeDxBlobMutationResult>;
+    deleteBlob(input: TreeDxBlobDeleteRequest): Promise<TreeDxBlobMutationResult>;
+    downloadBlob(input: TreeDxBlobDownloadRequest): Promise<TreeDxBlobDownload>;
+    uploadBlob(input: TreeDxBlobUploadRequest): Promise<TreeDxBlobMutationResult>;
+    createBlobUpload(input: TreeDxBlobUploadCreateRequest): Promise<TreeDxBlobUploadSession>;
+    uploadBlobPart(input: TreeDxBlobUploadPartRequest): Promise<TreeDxBlobUploadPart>;
+    completeBlobUpload(input: TreeDxBlobUploadCompleteRequest): Promise<TreeDxBlobMutationResult>;
+    abortBlobUpload(input: TreeDxBlobUploadAbortRequest): Promise<TreeDxBlobUploadSession>;
+    listArtifacts(input?: TreeDxArtifactListRequest): Promise<TreeDxArtifact[]>;
+    getArtifact(input: TreeDxArtifactGetRequest): Promise<TreeDxArtifact>;
+    deleteArtifact(input: TreeDxArtifactDeleteRequest): Promise<TreeDxArtifact>;
+    cleanupArtifacts(input?: TreeDxArtifactCleanupRequest): Promise<TreeDxArtifactCleanupResult>;
+    search(input: TreeDxSearchRequest): Promise<TreeDxSearchResult>;
+    status(input: TreeDxWorkspaceRequest): Promise<TreeDxStatus>;
+    diff(input: TreeDxWorkspaceRequest): Promise<TreeDxDiff>;
+    commit(input: TreeDxCommitRequest): Promise<TreeDxCommitResult>;
+    exec(input: TreeDxExecRequest): Promise<TreeDxExecResult>;
+    readRepositoryFiles(input: TreeDxRepositoryReadRequest): Promise<TreeDxRepositoryQueryResult>;
+    readRepositoryFile(input: TreeDxRepositoryReadRequest): Promise<TreeDxRepositoryQueryResult>;
+    listRepositoryPaths(input: TreeDxRepositoryPathsRequest): Promise<TreeDxRepositoryQueryResult>;
+    searchRepositoryFiles(input: TreeDxRepositorySearchRequest): Promise<TreeDxRepositoryQueryResult>;
+    queryRepository(input: TreeDxRepositoryQueryRequest): Promise<TreeDxRepositoryQueryResult>;
+    federatedSearch(input: TreeDxFederatedSearchRequest): Promise<TreeDxFederatedSearchResult>;
+    federatedQuery(input: TreeDxFederatedQueryRequest): Promise<TreeDxFederatedQueryResult>;
+    federatedContext(input: TreeDxFederatedContextRequest): Promise<TreeDxFederatedContextResult>;
+    federatedGraph(input: TreeDxFederatedGraphRequest): Promise<TreeDxFederatedGraphResult>;
+    refreshGraph(input?: TreeDxGraphRefreshRequest): Promise<TreeDxGraphRefreshResult>;
+    getGraphRefreshJob(input: TreeDxGraphRefreshJobRequest): Promise<TreeDxGraphRefreshJob>;
+    refreshSearchIndex(input?: TreeDxSearchIndexRefreshRequest): Promise<TreeDxSearchIndexRefreshResult>;
+    getSearchIndexStatus(input?: TreeDxSearchIndexStatusRequest): Promise<TreeDxSearchIndexStatus>;
+    compactSearchIndex(input?: TreeDxSearchIndexCompactRequest): Promise<TreeDxSearchIndexCompactResult>;
+    queryGraph(input: TreeDxGraphQueryRequest): Promise<TreeDxGraphQueryResult>;
+    searchGraphFiles(input: TreeDxGraphSearchRequest): Promise<SdkGraphSearchResult[]>;
+    searchGraphSections(input: TreeDxGraphSearchRequest): Promise<SdkGraphSearchResult[]>;
+    searchGraphEntities(input: TreeDxGraphSearchRequest): Promise<SdkGraphSearchResult[]>;
+    getGraphNode(input: TreeDxGraphNodeRequest): any;
+    getRelated(input: TreeDxGraphRelatedRequest): any;
+    getSubgraph(input: TreeDxGraphSubgraphRequest): any;
+    buildContext(input: TreeDxContextRequest): Promise<TreeDxContextResult>;
+    parseContextDsl(input: TreeDxCtxParseRequest): Promise<TreeDxCtxParseResult>;
+    graphSearch(path: string, input: TreeDxGraphSearchRequest): Promise<SdkGraphSearchResult[]>;
+}
+export declare function parseFilename(contentDisposition: string | null): string | undefined;