@treeseed/sdk 0.10.28 → 0.11.0

package/dist/sdk.js

@@ -3,6 +3,32 @@ import { normalizeAgentCliOptions } from "./cli-tools.js";
 import { ContentStore } from "./content-store.js";
 import { CloudflareD1AgentDatabase, MemoryAgentDatabase } from "./d1-store.js";
 import { ContentGraphRuntime } from "./graph.js";
+import {
+  createTreeDxClientFromAgentOptions,
+  LocalContentBackend,
+  LocalGraphBackend,
+  MissingTreeDxContentBackend,
+  resolveTreeDxOptions,
+  TreeDxContentBackend,
+  TreeDxGraphBackend,
+  TreeDxPortfolioResolver
+} from "./treedx-backends.js";
+import {
+  LocalGraphPort,
+  LocalRepositoryPort,
+  LocalRepositoryQueryPort,
+  TreeDxArtifactPort,
+  TreeDxExecPort,
+  TreeDxFederatedClient,
+  TreeDxFederatedPort,
+  TreeDxGraphAdapter,
+  TreeDxGraphPort,
+  TreeDxRegistryClient,
+  TreeDxRegistryPort,
+  TreeDxRepositoryPort,
+  TreeDxRepositoryQueryPort,
+  TreeDxClient as PublicTreeDxClient
+} from "./treedx/index.js";
 import { loadTreeseedPlugins } from "./platform/plugins.js";
 import { buildScopedModelRegistry, resolveModelDefinition } from "./model-registry.js";
 import { findDispatchCapability } from "./dispatch.js";
@@ -35,14 +61,22 @@ class AgentSdk {
   database;
   content;
   models;
+  ports;
+  treeDx;
+  localContentStore;
+  localGraphRuntime;
   graph;
   dispatchConfig;
   constructor(options = {}) {
-    const repoRoot = resolveSdkRepoRoot(options.repoRoot);
+    const rawTreeDxOptions = options.treeDx;
+    if (rawTreeDxOptions && !options.repoRoot && !options.models && !options.modelRegistry) {
+      throw new Error("AgentSdk TreeDX mode requires explicit models or modelRegistry.");
+    }
+    const repoRoot = options.repoRoot ? resolveSdkRepoRoot(options.repoRoot) : rawTreeDxOptions ? process.cwd() : resolveSdkRepoRoot();
     this.repoRoot = repoRoot;
     this.models = options.modelRegistry ?? buildScopedModelRegistry(repoRoot, options.models);
     this.database = options.database ?? new MemoryAgentDatabase();
-    this.content = new ContentStore(repoRoot, this.database, this.models);
+    this.localContentStore = new ContentStore(repoRoot, this.database, this.models);
     let plugins = options.plugins;
     if (!plugins) {
       try {
@@ -51,10 +85,123 @@ class AgentSdk {
         plugins = [];
       }
     }
-    this.graph = new ContentGraphRuntime(repoRoot, this.models, {
+    this.localGraphRuntime = new ContentGraphRuntime(repoRoot, this.models, {
       rankingProvider: options.graphRankingProvider,
       plugins
     });
+    const treeDxOptions = resolveTreeDxOptions(options.treeDx);
+    if (options.contentRepository?.adapter === "local") {
+      this.content = new LocalContentBackend(this.localContentStore);
+      this.graph = new LocalGraphBackend(this.localGraphRuntime);
+      this.ports = {
+        repository: new LocalRepositoryPort(this.localContentStore),
+        query: new LocalRepositoryQueryPort(this.localContentStore),
+        graph: new LocalGraphPort(this.localGraphRuntime)
+      };
+    } else if (treeDxOptions) {
+      const publicClient = rawTreeDxOptions?.client instanceof PublicTreeDxClient ? rawTreeDxOptions.client : new PublicTreeDxClient({
+        baseUrl: treeDxOptions.baseUrl,
+        token: treeDxOptions.token,
+        repoId: treeDxOptions.repoId,
+        fetch: treeDxOptions.fetchImpl
+      });
+      const publicFetch = (input, init) => {
+        const headers = init?.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init?.headers;
+        return (publicClient.fetchImpl ?? fetch)(input, {
+          ...init,
+          headers
+        });
+      };
+      const client = createTreeDxClientFromAgentOptions({
+        ...treeDxOptions,
+        fetchImpl: treeDxOptions.fetchImpl ?? publicFetch
+      });
+      const resolver = new TreeDxPortfolioResolver({
+        client,
+        repoId: treeDxOptions.repoId,
+        ref: treeDxOptions.ref,
+        repositoryHints: treeDxOptions.repositoryHints
+      });
+      const publicGraph = new TreeDxGraphAdapter({
+        client: publicClient,
+        repoId: treeDxOptions.repoId,
+        defaultRef: treeDxOptions.ref
+      });
+      const publicRegistry = rawTreeDxOptions?.registryRouting ? new TreeDxRegistryClient(publicClient) : void 0;
+      const publicFederated = publicRegistry ? new TreeDxFederatedClient({
+        registry: publicRegistry,
+        token: treeDxOptions.token,
+        fetch: treeDxOptions.fetchImpl
+      }) : void 0;
+      const publicExec = new TreeDxExecPort(publicClient);
+      const publicArtifact = new TreeDxArtifactPort(publicClient);
+      this.content = new TreeDxContentBackend({
+        client,
+        repoRoot,
+        models: this.models,
+        resolver,
+        directRepoId: treeDxOptions.repoId,
+        ref: treeDxOptions.ref,
+        workspaceId: treeDxOptions.workspaceId,
+        contentPathMap: treeDxOptions.contentPathMap,
+        localLeaseStore: this.localContentStore
+      });
+      this.graph = new TreeDxGraphBackend({
+        client,
+        resolver,
+        localRuntime: this.localGraphRuntime,
+        ref: treeDxOptions.ref
+      });
+      this.treeDx = {
+        client: publicClient,
+        graph: publicGraph,
+        registry: publicRegistry,
+        federated: publicFederated,
+        exec: publicExec,
+        artifact: publicArtifact
+      };
+      this.ports = {
+        repository: new TreeDxRepositoryPort(publicClient),
+        query: new TreeDxRepositoryQueryPort(publicClient),
+        graph: new TreeDxGraphPort(publicGraph),
+        registry: publicRegistry ? new TreeDxRegistryPort(publicRegistry) : void 0,
+        federated: publicFederated ? new TreeDxFederatedPort(publicFederated) : void 0,
+        exec: publicExec,
+        artifact: publicArtifact
+      };
+    } else if (rawTreeDxOptions?.client) {
+      const publicClient = rawTreeDxOptions.client instanceof PublicTreeDxClient ? rawTreeDxOptions.client : new PublicTreeDxClient(rawTreeDxOptions.client);
+      const publicGraph = new TreeDxGraphAdapter({
+        client: publicClient,
+        repoId: rawTreeDxOptions.repoId,
+        defaultRef: rawTreeDxOptions.ref
+      });
+      const publicExec = new TreeDxExecPort(publicClient);
+      const publicArtifact = new TreeDxArtifactPort(publicClient);
+      this.content = new LocalContentBackend(this.localContentStore);
+      this.graph = new LocalGraphBackend(this.localGraphRuntime);
+      this.treeDx = {
+        client: publicClient,
+        graph: publicGraph,
+        exec: publicExec,
+        artifact: publicArtifact
+      };
+      this.ports = {
+        repository: new TreeDxRepositoryPort(publicClient),
+        query: new TreeDxRepositoryQueryPort(publicClient),
+        graph: new TreeDxGraphPort(publicGraph),
+        exec: publicExec,
+        artifact: publicArtifact
+      };
+    } else {
+      this.content = new MissingTreeDxContentBackend();
+      this.graph = new LocalGraphBackend(this.localGraphRuntime);
+      this.ports = {
+        repository: new LocalRepositoryPort(this.localContentStore),
+        query: new LocalRepositoryQueryPort(this.localContentStore),
+        graph: new LocalGraphPort(this.localGraphRuntime)
+      };
+    }
     this.dispatchConfig = options.dispatch;
   }
   static createLocal(options) {
@@ -64,7 +211,8 @@ class AgentSdk {
       repoRoot,
       database: new CloudflareD1AgentDatabase(d1),
       models: options.models,
-      modelRegistry: options.modelRegistry
+      modelRegistry: options.modelRegistry,
+      contentRepository: { adapter: "local" }
     });
   }
   async resolveDispatchToken(source) {
@@ -89,6 +237,27 @@ class AgentSdk {
         transport: "sdk"
       });
     }
+    if (this.content instanceof MissingTreeDxContentBackend) {
+      const input = request.input ?? {};
+      if (request.operation === "read" || request.operation === "get") {
+        const definition = resolveModelDefinition(input.model, this.models);
+        const payload = await this.localContentStore.get({
+          ...input,
+          model: definition.name
+        });
+        return this.envelope(definition.name, request.operation === "read" ? "read" : "get", payload);
+      }
+      if (request.operation === "search") {
+        const definition = resolveModelDefinition(input.model, this.models);
+        const payload = await this.localContentStore.search({
+          ...input,
+          model: definition.name
+        });
+        return this.envelope(definition.name, "search", payload, {
+          count: payload.length
+        });
+      }
+    }
     return executeSdkOperation(this, request.operation, request.input ?? {});
   }
   async dispatch(request) {
@@ -164,7 +333,7 @@ class AgentSdk {
   }
   async pick(request) {
     const definition = resolveModelDefinition(request.model, this.models);
-    const payload = definition.storage === "content" ? await this.content.pick({ ...request, model: definition.name }) : await this.database.pick({ ...request, model: definition.name });
+    const payload = definition.storage === "content" ? await this.localContentStore.pick({ ...request, model: definition.name }) : await this.database.pick({ ...request, model: definition.name });
     return this.envelope(definition.name, "pick", payload, {
       claimed: Boolean(payload.item)
     });
@@ -423,43 +592,43 @@ class AgentSdk {
   }
   /** Advanced lexical graph primitive for file nodes. Prefer queryGraph() or buildContextPack() for AI-context retrieval. */
   searchFiles(query, options) {
-    return this.graph.searchFiles(query, options);
+    return this.localGraphRuntime.searchFiles(query, options);
   }
   /** Advanced lexical graph primitive for section nodes. Prefer queryGraph() or buildContextPack() for AI-context retrieval. */
   searchSections(query, options) {
-    return this.graph.searchSections(query, options);
+    return this.localGraphRuntime.searchSections(query, options);
   }
   /** Advanced lexical graph primitive for entity nodes. Prefer queryGraph() or buildContextPack() for AI-context retrieval. */
   searchEntities(query, options) {
-    return this.graph.searchEntities(query, options);
+    return this.localGraphRuntime.searchEntities(query, options);
   }
   /** Advanced graph primitive that returns one raw graph node by id. */
   getGraphNode(id) {
-    return this.graph.getNode(id);
+    return this.localGraphRuntime.getNode(id);
   }
   /** Advanced graph primitive for direct neighborhood inspection. Prefer queryGraph() for ranked retrieval. */
   getNeighbors(id, options) {
-    return this.graph.getNeighbors(id, options);
+    return this.localGraphRuntime.getNeighbors(id, options);
   }
   /** Advanced traversal primitive for direct reference walking. Prefer queryGraph() when you need ranking and ctx-aware behavior. */
   followReferences(id, options) {
-    return this.graph.followReferences(id, options);
+    return this.localGraphRuntime.followReferences(id, options);
   }
   /** Advanced graph primitive for incoming-link inspection. */
   getBacklinks(id, options) {
-    return this.graph.getBacklinks(id, options);
+    return this.localGraphRuntime.getBacklinks(id, options);
   }
   /** Advanced graph primitive for local relatedness. Prefer queryGraph() for the primary ranked graph workflow. */
   getRelated(id, options) {
-    return this.graph.getRelated(id, options);
+    return this.localGraphRuntime.getRelated(id, options);
   }
   /** Advanced traversal primitive for raw subgraph extraction. Prefer buildContextPack() when you need prompt-ready output. */
   getSubgraph(seedIds, options) {
-    return this.graph.getSubgraph(seedIds, options);
+    return this.localGraphRuntime.getSubgraph(seedIds, options);
   }
   /** Primary graph workflow helper. Resolves roots before ranking and traversal. */
   resolveSeeds(request) {
-    return this.graph.resolveSeeds(request);
+    return this.localGraphRuntime.resolveSeeds(request);
   }
   /** Primary graph workflow entrypoint for ranked graph retrieval. */
   queryGraph(request) {
@@ -475,11 +644,11 @@ class AgentSdk {
   }
   /** Primary graph workflow helper for resolving ids, paths, and anchors into graph nodes. */
   resolveReference(reference, options) {
-    return this.graph.resolveReference(reference, options);
+    return this.localGraphRuntime.resolveReference(reference, options);
   }
   /** Primary graph workflow helper for explaining why two nodes are connected. */
   explainReferenceChain(fromId, toId) {
-    return this.graph.explainReferenceChain(fromId, toId);
+    return this.localGraphRuntime.explainReferenceChain(fromId, toId);
   }
 }
 class ScopedAgentSdk {

package/dist/template-launch-requirements.js

@@ -268,9 +268,11 @@ function hostMetadataType(host) {
   if (metadataType === "web_host" || metadataType === "cloudflare" || metadataType === "web") return "web";
   if (metadataType === "email_host" || metadataType === "smtp" || metadataType === "email") return "email";
   if (metadataType === "ai_host" || metadataType === "ai") return "ai";
+  if (metadataType === "knowledge_library" || metadataType === "knowledge-library" || metadataType === "treedx") return "knowledge-library";
   if (host.provider === "smtp") return "email";
   if (host.provider === "cloudflare") return "web";
   if (host.provider === "github") return "repository";
+  if (host.provider === "treedx") return "knowledge-library";
   return metadataType ?? "";
 }
 function allRequirements(launchRequirements) {
@@ -305,6 +307,13 @@ function portableHostConfigValues(requirement, provider, alias) {
     values.smtp = { profile: alias };
     return values;
   }
+  if (requirement.type === "knowledge-library" && provider === "treedx") {
+    values.treeDx = {
+      instance: alias,
+      contentAccessMode: "treedx"
+    };
+    return values;
+  }
   return values;
 }
 function localHostMetadata(requirement, managed) {

package/dist/treedx/adapters.d.ts

@@ -0,0 +1,6 @@
+export { TreeDxRepositoryAdapter, resolveContentDir, type TreeDxContentMutationResult, type TreeDxRepositoryAdapterOptions, } from './repository-adapter.ts';
+export { TreeDxQueryAdapter, type TreeDxQueryAdapterOptions } from './query-adapter.ts';
+export { TreeDxGraphAdapter, type TreeDxGraphAdapterOptions } from './graph-adapter.ts';
+export { TreeDxWorkspaceAdapter, type TreeDxWorkspaceAdapterOptions } from './workspace-adapter.ts';
+export { LocalGraphPort, LocalRepositoryPort, LocalRepositoryQueryPort, TreeDxArtifactPort, TreeDxExecPort, TreeDxFederatedPort, TreeDxGraphPort, TreeDxRegistryPort, TreeDxRepositoryPort, TreeDxRepositoryQueryPort, } from './ports.ts';
+export type * from './ports.ts';

package/dist/treedx/adapters.js

@@ -0,0 +1,36 @@
+import {
+  TreeDxRepositoryAdapter,
+  resolveContentDir
+} from "./repository-adapter.js";
+import { TreeDxQueryAdapter } from "./query-adapter.js";
+import { TreeDxGraphAdapter } from "./graph-adapter.js";
+import { TreeDxWorkspaceAdapter } from "./workspace-adapter.js";
+import {
+  LocalGraphPort,
+  LocalRepositoryPort,
+  LocalRepositoryQueryPort,
+  TreeDxArtifactPort,
+  TreeDxExecPort,
+  TreeDxFederatedPort,
+  TreeDxGraphPort,
+  TreeDxRegistryPort,
+  TreeDxRepositoryPort,
+  TreeDxRepositoryQueryPort
+} from "./ports.js";
+export {
+  LocalGraphPort,
+  LocalRepositoryPort,
+  LocalRepositoryQueryPort,
+  TreeDxArtifactPort,
+  TreeDxExecPort,
+  TreeDxFederatedPort,
+  TreeDxGraphAdapter,
+  TreeDxGraphPort,
+  TreeDxQueryAdapter,
+  TreeDxRegistryPort,
+  TreeDxRepositoryAdapter,
+  TreeDxRepositoryPort,
+  TreeDxRepositoryQueryPort,
+  TreeDxWorkspaceAdapter,
+  resolveContentDir
+};

package/dist/treedx/client.d.ts

@@ -0,0 +1,222 @@
+import type { SdkGraphSearchResult, TreeDxAuditEvent, TreeDxAuthMode, TreeDxBlob, TreeDxBlobUploadAbortRequest, TreeDxBlobUploadCompleteRequest, TreeDxBlobUploadCreateRequest, TreeDxBlobUploadPart, TreeDxBlobUploadPartRequest, TreeDxBlobUploadSession, TreeDxBlobDeleteRequest, TreeDxBlobDownload, TreeDxBlobDownloadRequest, TreeDxBlobMutationResult, TreeDxBlobReadRequest, TreeDxBlobUploadRequest, TreeDxBlobWriteRequest, TreeDxCapabilityGrant, TreeDxCommitRequest, TreeDxCommitResult, TreeDxContextRequest, TreeDxContextResult, TreeDxCtxParseRequest, TreeDxCtxParseResult, TreeDxDiff, TreeDxEffectiveScope, TreeDxEffectiveScopeRequest, TreeDxExecRequest, TreeDxExecResult, TreeDxFetchRemoteRequest, TreeDxFetchRemoteResult, TreeDxFederatedContextRequest, TreeDxFederatedContextResult, TreeDxFederatedGraphRequest, TreeDxFederatedGraphResult, TreeDxFederatedQueryRequest, TreeDxFederatedQueryResult, TreeDxFederatedSearchRequest, TreeDxFederatedSearchResult, TreeDxArtifact, TreeDxArtifactCleanupRequest, TreeDxArtifactCleanupResult, TreeDxArtifactDeleteRequest, TreeDxArtifactDownload, TreeDxArtifactExportRequest, TreeDxArtifactGetRequest, TreeDxArtifactListRequest, TreeDxFederationQueryPlan, TreeDxFederationQueryPlanRequest, TreeDxFile, TreeDxFileMutationResult, TreeDxGraphNodeRequest, TreeDxGraphQueryRequest, TreeDxGraphQueryResult, TreeDxGraphRefreshJob, TreeDxGraphRefreshJobRequest, TreeDxGraphRefreshRequest, TreeDxGraphRefreshResult, TreeDxGraphRelatedRequest, TreeDxGraphSearchRequest, TreeDxGraphSubgraphRequest, TreeDxHealth, TreeDxListTreeRequest, TreeDxMigration, TreeDxMigrationRequest, TreeDxMirrorHealthRequest, TreeDxMirrorHealthResult, TreeDxMirrorPromotionRequest, TreeDxMirrorPromotionResult, TreeDxMirrorSyncRequest, TreeDxMirrorSyncResult, TreeDxNode, TreeDxPatchFileRequest, TreeDxReadFileRequest, TreeDxRepository, TreeDxRepositoryPathsRequest, TreeDxRepositoryPlacement, TreeDxRepositoryQueryRequest, TreeDxRepositoryQueryResult, TreeDxRepositoryReadRequest, TreeDxRepositorySearchRequest, TreeDxSearchRequest, TreeDxSearchIndexCompactRequest, TreeDxSearchIndexCompactResult, TreeDxSearchIndexRefreshRequest, TreeDxSearchIndexRefreshResult, TreeDxSearchIndexStatus, TreeDxSearchIndexStatusRequest, TreeDxSearchResult, TreeDxSnapshot, TreeDxSnapshotBuildRequest, TreeDxStorageBackupRequest, TreeDxStorageBackupResult, TreeDxStorageCompactRequest, TreeDxStorageCompactResult, TreeDxStorageMigration, TreeDxStorageMigrationPlanRequest, TreeDxStorageMigrationRollbackRequest, TreeDxStorageRestoreRequest, TreeDxStorageRestoreResult, TreeDxStorageRestoreVerifyRequest, TreeDxStatus, TreeDxTreeEntry, TreeDxClientOptions, TreeDxPushRequest, TreeDxPushResult, TreeDxWhoami, TreeDxWorkspace, TreeDxCreateWorkspaceRequest, TreeDxDeleteFileRequest, TreeDxDeepHealth, TreeDxWorkspaceRequest, TreeDxWriteFileRequest, TreeDxMetrics, TreeDxReadiness } from './types.ts';
+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 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 {
+    private readonly options;
+    readonly baseUrl: string;
+    private readonly token?;
+    private readonly defaultRepoId?;
+    private readonly fetchImpl;
+    constructor(options: TreeDxClientOptions);
+    private repoId;
+    private query;
+    private headers;
+    private fetchWithTimeout;
+    private request;
+    private requestBinary;
+    private requestBlobDownload;
+    private requestBlobUpload;
+    private assertBinaryOk;
+    private parseJsonResponse;
+    private throwApiError;
+    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>;
+    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>;
+    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>;
+    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): Promise<unknown>;
+    getRelated(input: TreeDxGraphRelatedRequest): Promise<Record<string, unknown>>;
+    getSubgraph(input: TreeDxGraphSubgraphRequest): Promise<Record<string, unknown>>;
+    buildContext(input: TreeDxContextRequest): Promise<TreeDxContextResult>;
+    parseContextDsl(input: TreeDxCtxParseRequest): Promise<TreeDxCtxParseResult>;
+    private graphSearch;
+}