@lucern/sdk 1.0.31 → 1.0.32

package/dist/client.d.ts

@@ -8,614 +8,942 @@ export type { LucernClientConfig } from "./client-config";
  * @returns The Lucern client with namespaced methods for beliefs, topics, evidence, decisions, and more.
  */
 export declare function createLucernClient(config?: LucernClientConfig): {
-    coordination: {
-        registerSession: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        heartbeatSession: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        endSession: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        listActiveSessions: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        sendAgentMessage: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        broadcastMessage: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        getInbox: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        getAgentInbox: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        claimFiles: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-    };
-    policy: {
-        checkPermission(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./policyClient").PermissionDecision>>;
-        listAccessibleTopics(input?: Parameters<(query?: import("./coreClient").GatewayScope & {
-            permission?: import("./policyClient").PermissionKind;
-            includeShared?: boolean;
-            principal?: string;
-            principalId?: string;
+    graph: {
+        nodes: import("./client-assembly-types").ClientNodesNamespace;
+        createEdge: (input: import("./graphClient").CreateEdgeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformGraphEdge>>;
+        neighborhood(args: Parameters<(query: import("./graphClient").NeighborhoodInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<import("./types").GraphNeighborhoodResponse>>;
+        queryLineage: (args_0: string, args_1?: number | undefined) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        getConfidenceHistory: (args_0: string) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        getOpinionHistory: (args_0: string) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        getAuditTrail: (nodeId: string, limit?: number) => Promise<{
+            entries: import("./client-assembly-types").AuditTrailEntry[];
+        }>;
+        traverse(args: {
+            startNode: string;
+            direction?: string;
+            maxDepth?: number;
+            topicId?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        analyze(args: {
+            topicId?: string;
             limit?: number;
-        }) => Promise<{
-            data: {
-                permission: import("./policyClient").PermissionKind;
-                topics: import("./policyClient").PolicyTopicRecord[];
-                total: number;
-                deniedTopics: {
-                    topicId: string;
-                    reasonCode: string;
-                }[];
-            };
-            correlationId: string;
-            idempotentReplay: boolean;
-            policyTraceId: string | null;
-            success: true;
-        }>>[0]): Promise<{
-            data: {
-                permission: import("./policyClient").PermissionKind;
-                topics: import("./policyClient").PolicyTopicRecord[];
-                total: number;
-                deniedTopics: {
-                    topicId: string;
-                    reasonCode: string;
-                }[];
-            };
-            correlationId: string;
-            idempotentReplay: boolean;
-            policyTraceId: string | null;
-            success: true;
+            metric?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        bias(args: {
+            topicId?: string;
+            threshold?: number;
+            limit?: number;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        gaps(args: {
+            topicId?: string;
+            minConfidence?: number;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        falsify(args: {
+            topicId?: string;
+            beliefId?: string;
+            beliefIds?: string[];
+            minConfidence?: number;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        traceEntityImpact(args: {
+            nodeId: string;
+            topicId?: string;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        searchBeliefs: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        findContradictions: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        bisectConfidence: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        listBeliefs: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        detectConfirmationBias(topicId: string, threshold?: number): Promise<{
+            topicId: string;
+            threshold: number;
         }>;
-        filterByPermission(input: import("./functionSurface").FunctionSurfaceInput): Promise<{
-            success: true;
-            data: import("./policyClient").FilterByPermissionResponse;
+        getStructureAnalysis(topicId: string): Promise<{
+            topicId: string;
+        }>;
+        getFalsificationQuestions(topicId: string, beliefIds?: string[]): Promise<{
+            topicId: string;
+            questions: unknown;
         }>;
-        compileCapabilitySlice(input: Parameters<(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>>[0], idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-        manageWritePolicy(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-        raw: {
-            listDecisions(query?: import("./coreClient").GatewayScope & {
-                action?: string;
-                decision?: string;
-                traceId?: string;
-                principalId?: string;
-                topicId?: string;
-                limit?: number;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "decisions">>>;
-            grant(input: import("./coreClient").GatewayScope & {
-                topicId: string;
-                permission: import("./policyClient").PermissionKind;
-                principal?: string;
-                principalId?: string;
-                groupId?: string;
-                beliefClusterId?: string;
-                expiresAt?: number;
-            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            revoke(input: import("./coreClient").GatewayScope & {
-                topicId: string;
-                principal?: string;
-                principalId?: string;
-                groupId?: string;
-                beliefClusterId?: string;
-            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listWritePolicies(query?: import("./coreClient").GatewayScope & {
-                topicId?: string;
-                role?: string;
-                toolCategory?: string;
-                enabled?: boolean;
-            }): Promise<{
-                data: {
-                    policies: import("./policyClient").WritePolicyRecord[];
-                };
-                correlationId: string;
-                idempotentReplay: boolean;
-                policyTraceId: string | null;
-                success: true;
-            }>;
-            createWritePolicy(input: import("./policyClient").WritePolicyCreateInput, idempotencyKey?: string): Promise<{
-                data: {
-                    id: string | undefined;
-                    created: boolean;
-                    policy: import("./policyClient").WritePolicyRecord | null;
-                };
-                correlationId: string;
-                idempotentReplay: boolean;
-                policyTraceId: string | null;
-                success: true;
-            }>;
-            updateWritePolicy(id: string, input: import("./policyClient").WritePolicyUpdateInput, idempotencyKey?: string): Promise<{
-                data: {
-                    id: string | undefined;
-                    updated: boolean;
-                    policy: import("./policyClient").WritePolicyRecord | null;
-                };
-                correlationId: string;
-                idempotentReplay: boolean;
-                policyTraceId: string | null;
-                success: true;
-            }>;
-            deleteWritePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-                id?: string;
-                deleted?: boolean;
-            }>>;
-            listRolePolicies(query?: import("./coreClient").GatewayScope): Promise<{
-                data: {
-                    policies: import("./policyClient").TenantPolicyRecord[];
-                };
-                correlationId: string;
-                idempotentReplay: boolean;
-                policyTraceId: string | null;
-                success: true;
-            }>;
-            createRolePolicy(input: import("./coreClient").GatewayScope & import("./policyClient").TenantPolicyClassificationFields & {
-                roleName: string;
-                description?: string;
-                permissions: import("./policyClient").TenantPolicyPermission[];
-                groupBindings?: string[];
-            }, idempotencyKey?: string): Promise<{
-                data: {
-                    policy: import("./policyClient").TenantPolicyRecord | null;
-                };
-                correlationId: string;
-                idempotentReplay: boolean;
-                policyTraceId: string | null;
-                success: true;
-            }>;
-            updateRolePolicy(id: string, input: import("./coreClient").GatewayScope & import("./policyClient").TenantPolicyClassificationFields & {
-                roleName: string;
-                description?: string;
-                permissions: import("./policyClient").TenantPolicyPermission[];
-                groupBindings?: string[];
-            }, idempotencyKey?: string): Promise<{
-                data: {
-                    policy: import("./policyClient").TenantPolicyRecord | null;
-                };
-                correlationId: string;
-                idempotentReplay: boolean;
-                policyTraceId: string | null;
-                success: true;
-            }>;
-            deleteRolePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            checkPermission(query: import("./coreClient").GatewayScope & {
-                topicId?: string;
-                permission?: import("./policyClient").PermissionKind;
-                principal?: string;
-                principalId?: string;
-                beliefClusterId?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./policyClient").PermissionDecision>>;
-            listAccessibleTopics(query?: import("./coreClient").GatewayScope & {
-                permission?: import("./policyClient").PermissionKind;
-                includeShared?: boolean;
-                principal?: string;
-                principalId?: string;
-                limit?: number;
-            }): Promise<{
-                data: {
-                    permission: import("./policyClient").PermissionKind;
-                    topics: import("./policyClient").PolicyTopicRecord[];
-                    total: number;
-                    deniedTopics: {
-                        topicId: string;
-                        reasonCode: string;
-                    }[];
-                };
-                correlationId: string;
-                idempotentReplay: boolean;
-                policyTraceId: string | null;
-                success: true;
-            }>;
-            filterByPermission(input: import("./coreClient").GatewayScope & {
-                topicIds?: string[];
-                permission?: import("./policyClient").PermissionKind;
-                principal?: string;
-                principalId?: string;
-            }): Promise<{
-                success: true;
-                data: import("./policyClient").FilterByPermissionResponse;
-            }>;
-        };
-    };
-    observations: {
-        ingest: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        ingestObservation: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        getContext: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        getObservationContext: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-    };
-    coding: {
-        getCodeContext: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        getChangeHistory: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        recordAttempt: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        getFailureLog: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
     };
-    contracts: {
-        create(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        createEpistemicContract(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        list(input?: {
-            beliefNodeId?: string;
-            contractId?: string;
-            status?: string;
-        }): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        evaluate(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        evaluateContract(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        getStatus(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        getContractStatus(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+    themes: {
+        listByTopic(input: {
+            topicId?: string;
+            projectId?: string;
+            query?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
-    bootstrap: {
-        generateSessionHandoff: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+    graphSearch: {
+        keywordSearchNodes(input: {
+            topicId?: string;
+            projectId?: string;
+            query?: string;
+            sourceText?: string;
+            nodeType?: string;
+            nodeTypes?: string[];
+            limit?: number;
+            cursor?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
-    hybrid: {
-        discover: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        hybridDiscover: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        resolveTopicSemantic: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        expandGraphNeighborhood: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        findRelatedNodes: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        analyzeGraphImpact: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        detectGraphDrift: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+    classifiers: {
+        listBeliefCandidates(input: {
+            topicId?: string;
+            projectId?: string;
+            classifierKey?: string;
+            query?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
-    embeddings: {
-        getByNodeIds(input: import("./embeddingsClient").GetEmbeddingsByNodeIdsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").EmbeddingRecord, "embeddings">>>;
-        listMissingForTopic(input: import("./embeddingsClient").ListMissingEmbeddingsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").MissingEmbeddingCandidate, "nodes">>>;
-        vectorSearchByTopic(input: import("./embeddingsClient").VectorSearchByTopicInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").VectorSearchMatch, "results">>>;
-        markEmbeddingBackfillQueued(input: import("./embeddingsClient").MarkEmbeddingBackfillQueuedInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-            queued: number;
-            topicId: string;
-            workspaceId: string;
-            nodeIds: string[];
-        }>>;
+    archetypes: {
+        getJudgmentSignature(input: {
+            topicId?: string;
+            projectId?: string;
+            principalId?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
-    graphAnalysis: {
-        listGraphIntelligenceQueries(input?: import("./graphAnalysisClient").ListGraphIntelligenceQueriesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphIntelligenceQueryCatalogResponse>>;
-        runGraphIntelligenceQuery(input: import("./graphAnalysisClient").RunGraphIntelligenceQueryInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphIntelligenceQueryRunResponse>>;
-        saveAnalysis(input: import("./graphAnalysisClient").SaveGraphAnalysisInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
-        listAnalyses(input: import("./graphAnalysisClient").ListGraphAnalysesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisRecord, "analyses">>>;
-        getLatestAnalysis(input: import("./graphAnalysisClient").GetLatestGraphAnalysisInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
-        saveSuggestions(input: import("./graphAnalysisClient").SaveGraphSuggestionsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisSuggestionsResponse>>;
-        updateSuggestionStatus(input: import("./graphAnalysisClient").UpdateGraphSuggestionStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisSuggestion>>;
-        listSuggestions(input: import("./graphAnalysisClient").ListGraphSuggestionsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisSuggestion, "suggestions">>>;
-        listGraphChanges(input: import("./graphAnalysisClient").ListGraphChangesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisChangeRecord, "changes">>>;
-        computeOrRequestAnalysis(input: import("./graphAnalysisClient").ComputeOrRequestGraphAnalysisInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
+    events: {
+        list(query?: Parameters<(query?: import("./gatewayFacades").EventsListQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").EventsListResult>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").EventsListResult>>;
+        replay(input: Parameters<(input: import("./gatewayFacades").ReplayEventsInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        recordEvent: (input: import("./eventingClient").RecordEventInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingRecord>>;
+        listEvents: (input: import("./eventingClient").EventingScope) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./eventingClient").EventingRecord, "events">>>;
+        listWebhooks: (input: import("./eventingClient").EventingScope) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./eventingClient").EventingWebhookRecord, "webhooks">>>;
+        enqueueDelivery: (input: import("./eventingClient").EnqueueDeliveryInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
+        recordDeliveryAttempt: (input: import("./eventingClient").RecordDeliveryAttemptInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
+        updateDeliveryStatus: (input: import("./eventingClient").UpdateDeliveryStatusInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
     };
-    graphRecommendations: {
-        listForTopic(input: import("./graphRecommendationsClient").GraphRecommendationListInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphRecommendationsClient").GraphRecommendationRecord, "recommendations">>>;
-        getRecommendation(recommendationId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphRecommendationsClient").GraphRecommendationRecord>>;
-        markRecommendationStatus(input: import("./graphRecommendationsClient").MarkGraphRecommendationStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphRecommendationsClient").GraphRecommendationRecord>>;
+    beliefs: {
+        create(input: import("./beliefsClient").CreateBeliefInput): Promise<import("./client-config").GatewayDataEnvelope<import("./types").PlatformBeliefRecord>>;
+        get(nodeId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").BeliefRecord>>;
+        refine(nodeId: string, textOrInput: string | {
+            text: string;
+            rationale?: string;
+        }, rationale?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").BeliefRecord>>;
+        updateRationale(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            rationale?: string;
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        linkBeliefs(input: Parameters<(input: {
+            fromNodeId: string;
+            toNodeId: string;
+            edgeType: string;
+            weight?: number;
+            context?: string;
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        unlinkEvidence(input: Parameters<(input: {
+            beliefNodeId?: string;
+            beliefId?: string;
+            insightId?: string;
+            evidenceId?: string;
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        updateCriticality(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            criticality: string;
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        batchUpdateCriticality(input: Parameters<(input: {
+            updates: import("./gatewayFacades").GatewayRecord[];
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        reassignTopic(input: Parameters<(input: {
+            beliefNodeIds?: string[];
+            beliefIds?: string[];
+            targetTopicId: string;
+            reason?: string;
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        fork(nodeId: string, input: import("./client-config").BeliefsCompatForkInput): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").BeliefRecord>>;
+        archive(nodeId: string, input?: string | {
+            reason?: string;
+            rationale?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        list(args: {
+            topicId?: string;
+            worktreeId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+            cursor?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").BeliefsListResult>>;
+        search: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        lineage(nodeId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").BeliefsLineageResult>>;
+        confidenceHistory(nodeId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        opinionHistory: (args_0: string) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        createContract(nodeId: string, input: Parameters<(id: string, input: import("./gatewayFacades").BeliefContractInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        bisect(nodeId: string, input: Parameters<(id: string, input: import("./gatewayFacades").BeliefBisectInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
     };
-    orgGraphSearch: {
-        search(input: import("./orgGraphSearchClient").OrgGraphSearchInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
-        getNode(input: import("./orgGraphSearchClient").GetOrgGraphNodeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResult>>;
-        listByProvenance(input: import("./orgGraphSearchClient").ListOrgGraphByProvenanceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
-        listPublishedFromWorkspace(input: import("./orgGraphSearchClient").ListPublishedFromWorkspaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
+    webhooks: {
+        create(input: Parameters<(input: import("./gatewayFacades").WebhookCreateInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        list(query?: Parameters<(query?: import("./gatewayFacades").WebhookListQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").WebhooksListResult>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").WebhooksListResult>>;
+        get(id: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        update(id: string, input: Parameters<(id: string, input: import("./gatewayFacades").WebhookUpdateInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        delete(id: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        test(id: string, input?: Parameters<(id: string, input?: import("./gatewayFacades").WebhookTestInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        deliveries(id: string, query?: Parameters<(id: string, query?: import("./gatewayFacades").WebhookDeliveriesQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        health(id: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
     };
-    ontologyLinks: {
-        [methodName: string]: unknown;
+    edges: {
+        create(args: import("./functionSurface").FunctionSurfaceInput & {
+            from?: unknown;
+            to?: unknown;
+            sourceId?: string;
+            targetId?: string;
+            edgeType: string;
+            topicId?: string;
+            confidence?: number;
+            weight?: number;
+            context?: string;
+            reasoning?: string;
+        }, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        createEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        update(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        updateEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        remove(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        removeEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        removeBetween(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        removeEdgesBetween(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        batchCreate(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        batchCreateEdges(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        delete(input: Parameters<(input: {
+            edgeIds: string[];
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        list(args: {
+            sourceId: string;
+            edgeType?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayList>>;
+        traverse(args: {
+            startNode: string;
+            direction?: string;
+            maxDepth?: number;
+            topicId?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
     };
-    graphStateClassifier: {
-        classifyNode(input: import("./graphStateClassifierClient").ClassifyNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphStateClassifierClient").GraphStateClassification>>;
-        classifyTopic(input: import("./graphStateClassifierClient").ClassifyTopicInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphStateClassifierClient").GraphStateClassification, "classifications">>>;
-        listClassifications(input: import("./graphStateClassifierClient").ListGraphStateClassificationsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphStateClassifierClient").GraphStateClassification, "classifications">>>;
-        recordClassification(input: import("./graphStateClassifierClient").RecordGraphStateClassificationInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphStateClassifierClient").GraphStateClassification>>;
+    evidence: {
+        create(args: import("./client-evidence-compat").EvidenceCompatInput): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        add: (args_0: import("./client-evidence-compat").EvidenceCompatInput) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        get(evidenceId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        list(args: {
+            topicId?: string;
+            targetId?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayList>>;
+        search(args: {
+            q?: string;
+            query?: string;
+            topicId?: string;
+            targetId?: string;
+            methodology?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayList>>;
+        link(args: {
+            evidenceId: string;
+            targetId?: string;
+            beliefId?: string;
+            questionId?: string;
+            targetType?: "belief" | "question" | string;
+            weight?: number;
+            evidenceRelation?: "supports" | "contradicts";
+            confidence?: number;
+            rationale?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").EvidenceLinkResult>>;
+        linkToBelief(args: {
+            evidenceId: string;
+            beliefId: string;
+            weight?: number;
+            evidenceRelation?: "supports" | "contradicts";
+            confidence?: number;
+            rationale?: string;
+        }): Promise<{
+            beliefId: string;
+        }>;
+        classifyEvidence(beliefId: string, evidenceId: string, config?: Parameters<(beliefId: string, evidenceId: string, classificationConfig?: import("./evidenceClient").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./evidenceClient").ClassifyEvidenceResult>>>[2], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./evidenceClient").ClassifyEvidenceResult>>;
+        classifyEvidenceBatch(beliefId: string, evidence: Parameters<(beliefId: string, evidence: import("./evidenceClient").ClassifyEvidenceBatchItem[], classificationConfig?: import("./evidenceClient").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./evidenceClient").ClassifyEvidenceBatchResult>>>[1], config?: Parameters<(beliefId: string, evidence: import("./evidenceClient").ClassifyEvidenceBatchItem[], classificationConfig?: import("./evidenceClient").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./evidenceClient").ClassifyEvidenceBatchResult>>>[2], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./evidenceClient").ClassifyEvidenceBatchResult>>;
+        updateStatus(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        update(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        flagIncorrect(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        remove(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        updateVerificationStatus(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
     };
-    modelRuntime: {
-        listModels(input: import("./modelRuntimeClient").ModelRuntimeScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./modelRuntimeClient").ModelRegistryRecord, "models">>>;
-        getModel(input: import("./modelRuntimeClient").ModelRuntimeScope & {
-            modelId: string;
-        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelRegistryRecord>>;
-        listFunctionSlots(input: import("./modelRuntimeClient").ModelRuntimeScope & {
-            functionName?: string;
-        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./modelRuntimeClient").ModelFunctionSlot, "slots">>>;
-        resolveSlot(input: import("./modelRuntimeClient").ResolveModelSlotInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelFunctionSlot>>;
-        updateSlotConfig(input: import("./modelRuntimeClient").UpdateModelSlotConfigInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelFunctionSlot>>;
-    };
-    jobs: {
-        enqueue(input: import("./jobsClient").EnqueueJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
-        list(input: import("./jobsClient").JobsScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./jobsClient").JobRecord, "jobs">>>;
-        claim(input: import("./jobsClient").ClaimJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
-        updateStatus(input: import("./jobsClient").UpdateJobStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
-        retry(input: import("./jobsClient").RetryJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
-        recordRunStart(input: import("./jobsClient").RecordJobRunStartInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRunRecord>>;
-        recordRunFinish(input: import("./jobsClient").RecordJobRunFinishInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRunRecord>>;
-    };
-    telemetry: {
-        logSystemEvent(input: import("./telemetry-client").LogSystemEventInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-            eventId?: string;
-            recorded: boolean;
-        }>>;
-        logToolCallsBatch(input: import("./telemetry-client").LogToolCallsBatchInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-            recorded: number;
-        }>>;
-        recordEpistemicAudit(input: import("./telemetry-client").RecordEpistemicAuditInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-            auditId?: string;
-            recorded: boolean;
-        }>>;
-        recordPolicyDecision(input: import("./telemetry-client").RecordTelemetryPolicyDecisionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-            decisionId?: string;
-            recorded: boolean;
-        }>>;
-        startRun(input: import("./telemetry-client").StartTelemetryRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./telemetry-client").TelemetryRunRecord>>;
-        finishRun(input: import("./telemetry-client").FinishTelemetryRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./telemetry-client").TelemetryRunRecord>>;
-        listRuns(input: import("./telemetry-client").TelemetryScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./telemetry-client").TelemetryRunRecord, "runs">>>;
-    };
-    publication: {
-        [methodName: string]: unknown;
-    };
-    contentPublication: {
-        [methodName: string]: unknown;
+    sources: {
+        upsert(input: Parameters<(spec: import("./sources-client").UpsertSourceSpec, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformSourceRecord>>>[0], idempotencyKey?: Parameters<(spec: import("./sources-client").UpsertSourceSpec, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformSourceRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./types").PlatformSourceRecord>>;
+        get(sourceId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./types").PlatformSourceRecord>>;
     };
-    tools: {
-        listCatalog: (input: import("./toolRegistryClient").ToolRegistryQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
-        listExecutable: (input: import("./toolRegistryClient").ToolRegistryQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
-        listEffectiveTools: (input: import("./toolRegistryClient").EffectiveToolsQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
-        upsertCoreTools: (input: import("./toolRegistryClient").UpsertCoreToolsInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
-        setPackToolsStatus: (input: import("./toolRegistryClient").SetPackToolsStatusInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
-        createAcl: (input: import("./toolRegistryClient").CreateToolAclInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./toolRegistryClient").ToolAclRecord>>;
-        deleteAcl: (input: import("./toolRegistryClient").DeleteToolAclInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<{
-            aclId: string;
-            deleted: boolean;
-        }>>;
-        registerCustomTool: (input: import("./toolRegistryClient").RegisterCustomToolInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./toolRegistryClient").ToolCatalogEntry>>;
-        register: typeof registerCustomTool;
-        unregister: typeof unregisterCustomTool;
-        list: typeof listRegisteredCustomTools;
-        clear: typeof clearRegisteredCustomTools;
-        invoke(name: string, input?: import("./client-config").CustomToolInput): Promise<unknown>;
-        namespace: (namespace: string) => CustomToolNamespace;
+    questions: {
+        create(args: {
+            text: string;
+            topicId?: string;
+            priority?: string;
+            linkedBeliefId?: string;
+            metadata?: import("./types").JsonObject;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        get(questionId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        refine(questionId: string, input: string | {
+            text?: string;
+            question?: string;
+            rationale?: string;
+            linkedWorktreeId?: string;
+        }, refinementReason?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        list(args: {
+            topicId?: string;
+            status?: string;
+            priority?: string;
+            worktreeId?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").QuestionsListResult>>;
+        updateStatus(questionId: string, status: string, rationale?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        batchCreate(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        add(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        updatePriority(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        advanceToConviction(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        updateConviction(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        finalizeConviction(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        update(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        delete(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        answer(questionId: string, input: {
+            text: string;
+            confidence?: string;
+            evidenceIds?: string[];
+            rationale?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        archive(questionId: string, reason?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        linkEvidence(args: {
+            evidenceId: string;
+            questionId: string;
+            relevance?: number;
+            weight?: number;
+            rationale?: string;
+        }): Promise<{
+            questionId: string;
+            relevance: number | undefined;
+        }>;
+        getHighPriority(args: {
+            topicId?: string;
+            limit?: number;
+            includeAnswered?: boolean;
+        }): Promise<{
+            questions: ({
+                priority?: string;
+            } & Record<string, unknown>)[];
+        }>;
+        findMissing(args: {
+            topicId?: string;
+            minConfidence?: number;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
-    packs: {
-        ensurePack: () => Promise<void>;
-        readonly isInstalled: boolean;
-        listCatalog: () => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
-        catalog: () => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
-        listStates: (query?: import("./coreClient").GatewayScope) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
-        states: (query?: import("./coreClient").GatewayScope) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
-        install: (input: import("./packsClient").PackInstallInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-        enable: (input: import("./packsClient").PackEnableInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-        disable: (input: import("./packsClient").PackDisableInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+    coordination: {
+        registerSession: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        heartbeatSession: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        endSession: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        listActiveSessions: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        sendAgentMessage: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        broadcastMessage: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getInbox: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getAgentInbox: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        claimFiles: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
     };
-    nodes: import("./client-assembly-types").ClientNodesNamespace;
-    controlPlane: {
-        identity: {
-            resolveInteractivePrincipal: (input: import("./control-plane").ResolveInteractivePrincipalInput) => Promise<import("./control-plane").ResolveInteractivePrincipalResponse>;
-        };
-        raw: {
-            identity: {
-                resolveInteractivePrincipal(input: import("./control-plane").ResolveInteractivePrincipalInput): Promise<import("./control-plane").ResolveInteractivePrincipalResponse>;
+    policy: {
+        checkPermission(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./policyClient").PermissionDecision>>;
+        listAccessibleTopics(input?: Parameters<(query?: import("./coreClient").GatewayScope & {
+            permission?: import("./policyClient").PermissionKind;
+            includeShared?: boolean;
+            principal?: string;
+            principalId?: string;
+            limit?: number;
+        }) => Promise<{
+            correlationId: string;
+            idempotentReplay: boolean;
+            policyTraceId: string | null;
+            success: true;
+            data: {
+                permission: import("./policyClient").PermissionKind;
+                topics: import("./policyClient").PolicyTopicRecord[];
+                total: number;
+                deniedTopics: {
+                    topicId: string;
+                    reasonCode: string;
+                }[];
             };
-        };
-    };
-    identity: {
-        access: {
-            normalizePrincipal: typeof import("./accessControl").normalizeCanonicalPrincipalIdentity;
-            checkAccess: (input: import("./accessControl").RequireAccessInput, idempotencyKey?: string) => Promise<import("./accessControl").AccessCheckResult>;
-            requireAccess: (input: import("./accessControl").RequireAccessInput, idempotencyKey?: string) => Promise<import("./accessControl").AccessCheckResult>;
-            canAccess: (input: import("./accessControl").RequireAccessInput, idempotencyKey?: string) => Promise<boolean>;
-        };
-        resolveInteractivePrincipal: (input: import("./control-plane").ResolveInteractivePrincipalInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./control-plane").ResolvedInteractivePrincipalContext>>;
-        evaluatePolicy: (input: import("./identityClient").PolicyEvaluationInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").PolicyDecisionRecord>>;
-        recordPolicyDecision: (input: import("./identityClient").RecordPolicyDecisionInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").PolicyDecisionRecord>>;
-        putSecretReference: (input: import("./identityClient").PutTenantSecretReferenceInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").TenantSecretReference>>;
-        createPrincipal: (input: import("./coreClient").GatewayScope & {
-            principalId: string;
-            principalType: "user" | "group" | "service" | "external_viewer";
-            clerkId?: string;
-            email?: string;
-            displayName?: string;
-            status?: "active" | "invited" | "suspended" | "disabled" | "revoked";
-            metadata?: import("./types").JsonObject;
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-        updatePrincipal: (input: import("./coreClient").GatewayScope & {
-            principalId: string;
-            principalType: "user" | "group" | "service" | "external_viewer";
-            clerkId?: string;
-            email?: string;
-            displayName?: string;
-            status?: "active" | "invited" | "suspended" | "disabled" | "revoked";
-            metadata?: import("./types").JsonObject;
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        }>>[0]): Promise<{
+            correlationId: string;
+            idempotentReplay: boolean;
+            policyTraceId: string | null;
+            success: true;
+            data: {
+                permission: import("./policyClient").PermissionKind;
+                topics: import("./policyClient").PolicyTopicRecord[];
+                total: number;
+                deniedTopics: {
+                    topicId: string;
+                    reasonCode: string;
+                }[];
+            };
+        }>;
+        filterByPermission(input: import("./functionSurface").FunctionSurfaceInput): Promise<{
+            success: true;
+            data: import("./policyClient").FilterByPermissionResponse;
+        }>;
+        compileCapabilitySlice(input: Parameters<(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>>[0], idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+        manageWritePolicy(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
         raw: {
-            whoami(): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").SdkPrincipalContext>>;
-            resolveInteractivePrincipal(input: import("./control-plane").ResolveInteractivePrincipalInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./control-plane").ResolvedInteractivePrincipalContext>>;
-            listPrincipals(query?: import("./coreClient").GatewayScope & {
-                status?: string;
-                principalType?: string;
-                query?: string;
+            listDecisions(query?: import("./coreClient").GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
                 limit?: number;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "principals">>>;
-            createPrincipal(input: import("./coreClient").GatewayScope & {
-                principalId: string;
-                principalType: "user" | "group" | "service" | "external_viewer";
-                clerkId?: string;
-                email?: string;
-                displayName?: string;
-                status?: "active" | "invited" | "suspended" | "disabled" | "revoked";
-                metadata?: import("./types").JsonObject;
-            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            updatePrincipal: (input: import("./coreClient").GatewayScope & {
-                principalId: string;
-                principalType: "user" | "group" | "service" | "external_viewer";
-                clerkId?: string;
-                email?: string;
-                displayName?: string;
-                status?: "active" | "invited" | "suspended" | "disabled" | "revoked";
-                metadata?: import("./types").JsonObject;
-            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            upsertPrincipal: (input: import("./coreClient").GatewayScope & {
-                principalId: string;
-                principalType: "user" | "group" | "service" | "external_viewer";
-                clerkId?: string;
-                email?: string;
-                displayName?: string;
-                status?: "active" | "invited" | "suspended" | "disabled" | "revoked";
-                metadata?: import("./types").JsonObject;
-            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listKeys(query?: import("./coreClient").GatewayScope & {
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "decisions">>>;
+            grant(input: import("./coreClient").GatewayScope & {
+                topicId: string;
+                permission: import("./policyClient").PermissionKind;
+                principal?: string;
                 principalId?: string;
-                status?: string;
-                limit?: number;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "keys">>>;
-            createKey(input: import("./coreClient").GatewayScope & {
-                principalId: string;
-                keyId?: string;
-                token?: string;
-                scopes?: string[];
-                environment?: "sandbox" | "production";
-                expiresInDays?: number;
-                rateLimitTier?: "free" | "developer" | "partner";
-                metadata?: import("./types").JsonObject;
+                groupId?: string;
+                beliefClusterId?: string;
+                expiresAt?: number;
             }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            rotateKey(keyId: string, input?: {
-                replacementKeyId?: string;
-                replacementToken?: string;
-                replacementExpiresInDays?: number;
-                gracePeriodHours?: number;
+            revoke(input: import("./coreClient").GatewayScope & {
+                topicId: string;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
             }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            deleteKey: (keyId: string, input?: {
-                reason?: string;
-            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            revokeKey: (keyId: string, input?: {
-                reason?: string;
-            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            searchClerkUsers(q: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").ClerkUserSearchResult[]>>;
-            getTenantConfig(input: import("./identityClient").TenantIdentityScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").TenantIdentityConfigRecord>>;
-            updateTenantConfig(input: import("./identityClient").UpdateTenantConfigInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").TenantIdentityConfigRecord>>;
-            listIntegrations(input: import("./identityClient").TenantIdentityScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./identityClient").TenantIntegrationRecord, "integrations">>>;
-            upsertIntegration(input: import("./identityClient").UpsertTenantIntegrationInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").TenantIntegrationRecord>>;
-            listSecrets(input: import("./identityClient").TenantIdentityScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./identityClient").TenantSecretReference, "secrets">>>;
-            putSecretReference(input: import("./identityClient").PutTenantSecretReferenceInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").TenantSecretReference>>;
-            evaluatePolicy(input: import("./identityClient").PolicyEvaluationInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").PolicyDecisionRecord>>;
-            recordPolicyDecision(input: import("./identityClient").RecordPolicyDecisionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").PolicyDecisionRecord>>;
+            listWritePolicies(query?: import("./coreClient").GatewayScope & {
+                topicId?: string;
+                role?: string;
+                toolCategory?: string;
+                enabled?: boolean;
+            }): Promise<{
+                correlationId: string;
+                idempotentReplay: boolean;
+                policyTraceId: string | null;
+                success: true;
+                data: {
+                    policies: import("./policyClient").WritePolicyRecord[];
+                };
+            }>;
+            createWritePolicy(input: import("./policyClient").WritePolicyCreateInput, idempotencyKey?: string): Promise<{
+                correlationId: string;
+                idempotentReplay: boolean;
+                policyTraceId: string | null;
+                success: true;
+                data: {
+                    id: string | undefined;
+                    created: boolean;
+                    policy: import("./policyClient").WritePolicyRecord | null;
+                };
+            }>;
+            updateWritePolicy(id: string, input: import("./policyClient").WritePolicyUpdateInput, idempotencyKey?: string): Promise<{
+                correlationId: string;
+                idempotentReplay: boolean;
+                policyTraceId: string | null;
+                success: true;
+                data: {
+                    id: string | undefined;
+                    updated: boolean;
+                    policy: import("./policyClient").WritePolicyRecord | null;
+                };
+            }>;
+            deleteWritePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+                id?: string;
+                deleted?: boolean;
+            }>>;
+            listRolePolicies(query?: import("./coreClient").GatewayScope): Promise<{
+                correlationId: string;
+                idempotentReplay: boolean;
+                policyTraceId: string | null;
+                success: true;
+                data: {
+                    policies: import("./policyClient").TenantPolicyRecord[];
+                };
+            }>;
+            createRolePolicy(input: import("./coreClient").GatewayScope & import("./policyClient").TenantPolicyClassificationFields & {
+                roleName: string;
+                description?: string;
+                permissions: import("./policyClient").TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                correlationId: string;
+                idempotentReplay: boolean;
+                policyTraceId: string | null;
+                success: true;
+                data: {
+                    policy: import("./policyClient").TenantPolicyRecord | null;
+                };
+            }>;
+            updateRolePolicy(id: string, input: import("./coreClient").GatewayScope & import("./policyClient").TenantPolicyClassificationFields & {
+                roleName: string;
+                description?: string;
+                permissions: import("./policyClient").TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                correlationId: string;
+                idempotentReplay: boolean;
+                policyTraceId: string | null;
+                success: true;
+                data: {
+                    policy: import("./policyClient").TenantPolicyRecord | null;
+                };
+            }>;
+            deleteRolePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            checkPermission(query: import("./coreClient").GatewayScope & {
+                topicId?: string;
+                permission?: import("./policyClient").PermissionKind;
+                principal?: string;
+                principalId?: string;
+                beliefClusterId?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./policyClient").PermissionDecision>>;
+            listAccessibleTopics(query?: import("./coreClient").GatewayScope & {
+                permission?: import("./policyClient").PermissionKind;
+                includeShared?: boolean;
+                principal?: string;
+                principalId?: string;
+                limit?: number;
+            }): Promise<{
+                correlationId: string;
+                idempotentReplay: boolean;
+                policyTraceId: string | null;
+                success: true;
+                data: {
+                    permission: import("./policyClient").PermissionKind;
+                    topics: import("./policyClient").PolicyTopicRecord[];
+                    total: number;
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                };
+            }>;
+            filterByPermission(input: import("./coreClient").GatewayScope & {
+                topicIds?: string[];
+                permission?: import("./policyClient").PermissionKind;
+                principal?: string;
+                principalId?: string;
+            }): Promise<{
+                success: true;
+                data: import("./policyClient").FilterByPermissionResponse;
+            }>;
         };
-        whoami(): Promise<{
-            authMode?: string;
-            clerkId?: string;
-            delegatedBy?: string;
-            expiresAt?: number;
-            groupIds?: string[];
-            isPlatformAdmin: boolean;
-            isTenantAdmin: boolean;
-            isWorkspaceAdmin: boolean;
-            permit?: {
-                subject: string;
-                tenant: string;
-                workspace?: string;
-            };
-            permittedPackKeys?: string[];
-            permittedToolNames?: string[];
-            principalId: string;
-            principalStatus?: string;
-            principalType: "user" | "human" | "service" | "group" | "external_viewer" | "agent";
-            roles: string[];
-            scopes: string[];
-            sessionId?: string;
-            tenantId: string | null;
-            tenantStatus?: string;
-            workspaceId: string | null;
-            workspaceStatus?: string;
-            correlationId: string;
-            data: import("./types").SdkPrincipalContext;
-            idempotentReplay: boolean;
-            policyTraceId: string | null;
-            success: true;
-        }>;
     };
-    mcp: {
-        bootstrapSession: (input?: import("./mcpClient").McpBootstrapSessionInput) => Promise<import("./mcpClient").McpBootstrapSessionResponse>;
-        checkWritePolicy: (input: import("./mcpClient").McpCheckWritePolicyInput) => Promise<import("./mcpClient").McpCheckWritePolicyResponse>;
-        beginBuildSession: (input: import("./mcpClient").McpBeginBuildSessionInput) => Promise<import("./mcpClient").McpBeginBuildSessionResponse>;
-        evaluateEngineeringContract: (input: import("./mcpClient").McpEvaluateEngineeringContractInput) => Promise<import("./mcpClient").McpContractEvaluationResponse>;
-        evaluateResearchContract: (input: import("./mcpClient").McpEvaluateResearchContractInput) => Promise<import("./mcpClient").McpContractEvaluationResponse>;
+    observations: {
+        ingest: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        ingestObservation: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getContext: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getObservationContext: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
     };
-    auth: {
-        device: {
-            createCode: (input?: import("./authDeviceClient").DeviceCodeInput) => Promise<import("./authDeviceClient").DeviceCodeResponse>;
-            pollToken: (deviceCode: string) => Promise<import("./authDeviceClient").DeviceTokenResponse>;
-        };
+    coding: {
+        getCodeContext: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getChangeHistory: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        recordAttempt: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getFailureLog: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
     };
-    custom: CustomToolNamespace;
-    extensions: Record<string, CustomToolNamespace>;
-    raw: {
-        beliefs: {
-            createBelief(input: import("./beliefsClient").CreateBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
-            refineBelief(beliefId: string, input: import("./beliefsClient").RefineBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
-            getOpinionHistory: (beliefId: string) => Promise<import("./beliefsClient").OpinionHistoryEntry[]>;
-            getConfidenceHistory: (beliefId: string) => Promise<import("./beliefsClient").OpinionHistoryEntry[]>;
-            forkBelief(beliefId: string, input: import("./beliefsClient").ForkBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ForkBeliefResponse>>;
-            updateBeliefRationale(input: import("./beliefsClient").UpdateBeliefRationaleInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            linkBeliefs(input: import("./beliefsClient").LinkBeliefsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            unlinkBeliefEvidence(input: import("./beliefsClient").UnlinkBeliefEvidenceInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            updateBeliefCriticality(input: import("./beliefsClient").UpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            batchUpdateBeliefCriticality(input: import("./beliefsClient").BatchUpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            reassignBeliefsTopic(input: import("./beliefsClient").ReassignBeliefsTopicInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-        };
-        sources: {
-            upsert(spec: import("./sources-client").UpsertSourceSpec, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformSourceRecord>>;
-            get(sourceId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformSourceRecord>>;
-        };
-        evidence: {
-            classifyEvidence(beliefId: string, evidenceId: string, classificationConfig?: import("./evidenceClient").EvidenceClassificationRequestConfig, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./evidenceClient").ClassifyEvidenceResult>>;
-            classifyEvidenceBatch(beliefId: string, evidence: import("./evidenceClient").ClassifyEvidenceBatchItem[], classificationConfig?: import("./evidenceClient").EvidenceClassificationRequestConfig, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./evidenceClient").ClassifyEvidenceBatchResult>>;
-        };
-        embeddings: {
-            getByNodeIds(input: import("./embeddingsClient").GetEmbeddingsByNodeIdsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").EmbeddingRecord, "embeddings">>>;
-            listMissingForTopic(input: import("./embeddingsClient").ListMissingEmbeddingsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").MissingEmbeddingCandidate, "nodes">>>;
-            vectorSearchByTopic(input: import("./embeddingsClient").VectorSearchByTopicInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").VectorSearchMatch, "results">>>;
-            markEmbeddingBackfillQueued(input: import("./embeddingsClient").MarkEmbeddingBackfillQueuedInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-                queued: number;
-                topicId: string;
-                workspaceId: string;
-                nodeIds: string[];
-            }>>;
-        };
-        eventing: {
-            recordEvent(input: import("./eventingClient").RecordEventInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingRecord>>;
-            listEvents(input: import("./eventingClient").EventingScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./eventingClient").EventingRecord, "events">>>;
-            listWebhooks(input: import("./eventingClient").EventingScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./eventingClient").EventingWebhookRecord, "webhooks">>>;
-            enqueueDelivery(input: import("./eventingClient").EnqueueDeliveryInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
-            recordDeliveryAttempt(input: import("./eventingClient").RecordDeliveryAttemptInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
-            updateDeliveryStatus(input: import("./eventingClient").UpdateDeliveryStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
-        };
-        graph: {
-            listNodes(query: import("./graphClient").ListNodesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PlatformGraphNode, "nodes">>>;
-            getNode(query: import("./graphClient").GetNodeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformGraphNode>>;
-            createNode(input: import("./graphClient").CreateNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformGraphNode>>;
-            updateNode(input: import("./graphClient").UpdateNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformGraphNode>>;
-            batchCreateNodes(input: import("./graphClient").BatchCreateNodesInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            supersedeNode(input: import("./graphClient").SupersedeNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            verifyNode(input: import("./graphClient").VerifyNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            hardDeleteNode(input: import("./graphClient").HardDeleteNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            listEdges(query: import("./graphClient").ListEdgesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PlatformGraphEdge, "edges">>>;
-            createEdge(input: import("./graphClient").CreateEdgeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformGraphEdge>>;
-            deleteEdge(query: import("./graphClient").DeleteEdgeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").DeleteEdgeResponse>>;
-            neighborhood(query: import("./graphClient").NeighborhoodInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>;
-            traverse(query: import("./graphClient").TraverseInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            analyze(query?: import("./graphClient").AnalyzeInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            bias(query?: import("./graphClient").BiasInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            gaps(query: import("./graphClient").GapsInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            search(query: import("./graphClient").SearchInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            getPath(query: import("./graphClient").PathInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GraphPathResponse>>;
-            getAnalytics(query?: import("./graphClient").AnalyticsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GraphAnalyticsResponse<import("./types").GraphAnalyticsMetric>>>;
-        } & {
-            queryNodes: (query: import("./graphClient").ListNodesInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PlatformGraphNode, "nodes">>>;
-            queryEdges: (query: import("./graphClient").ListEdgesInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PlatformGraphEdge, "edges">>>;
-            getNeighborhood: (query: import("./graphClient").NeighborhoodInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>;
-        };
-        graphAnalysis: {
-            listGraphIntelligenceQueries(input?: import("./graphAnalysisClient").ListGraphIntelligenceQueriesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphIntelligenceQueryCatalogResponse>>;
-            runGraphIntelligenceQuery(input: import("./graphAnalysisClient").RunGraphIntelligenceQueryInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphIntelligenceQueryRunResponse>>;
-            saveAnalysis(input: import("./graphAnalysisClient").SaveGraphAnalysisInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
-            listAnalyses(input: import("./graphAnalysisClient").ListGraphAnalysesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisRecord, "analyses">>>;
-            getLatestAnalysis(input: import("./graphAnalysisClient").GetLatestGraphAnalysisInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
-            saveSuggestions(input: import("./graphAnalysisClient").SaveGraphSuggestionsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisSuggestionsResponse>>;
-            updateSuggestionStatus(input: import("./graphAnalysisClient").UpdateGraphSuggestionStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisSuggestion>>;
-            listSuggestions(input: import("./graphAnalysisClient").ListGraphSuggestionsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisSuggestion, "suggestions">>>;
-            listGraphChanges(input: import("./graphAnalysisClient").ListGraphChangesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisChangeRecord, "changes">>>;
-            computeOrRequestAnalysis(input: import("./graphAnalysisClient").ComputeOrRequestGraphAnalysisInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
+    contracts: {
+        create(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        createEpistemicContract(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        list(input?: {
+            beliefNodeId?: string;
+            contractId?: string;
+            status?: string;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        evaluate(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        evaluateContract(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        getStatus(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        getContractStatus(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+    };
+    bootstrap: {
+        generateSessionHandoff: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+    };
+    hybrid: {
+        discover: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        hybridDiscover: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        resolveTopicSemantic: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        expandGraphNeighborhood: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        findRelatedNodes: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        analyzeGraphImpact: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        detectGraphDrift: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+    };
+    embeddings: {
+        getByNodeIds(input: import("./embeddingsClient").GetEmbeddingsByNodeIdsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").EmbeddingRecord, "embeddings">>>;
+        listMissingForTopic(input: import("./embeddingsClient").ListMissingEmbeddingsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").MissingEmbeddingCandidate, "nodes">>>;
+        vectorSearchByTopic(input: import("./embeddingsClient").VectorSearchByTopicInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").VectorSearchMatch, "results">>>;
+        markEmbeddingBackfillQueued(input: import("./embeddingsClient").MarkEmbeddingBackfillQueuedInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+            queued: number;
+            topicId: string;
+            workspaceId: string;
+            nodeIds: string[];
+        }>>;
+    };
+    graphAnalysis: {
+        listGraphIntelligenceQueries(input?: import("./graphAnalysisClient").ListGraphIntelligenceQueriesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphIntelligenceQueryCatalogResponse>>;
+        runGraphIntelligenceQuery(input: import("./graphAnalysisClient").RunGraphIntelligenceQueryInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphIntelligenceQueryRunResponse>>;
+        saveAnalysis(input: import("./graphAnalysisClient").SaveGraphAnalysisInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
+        listAnalyses(input: import("./graphAnalysisClient").ListGraphAnalysesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisRecord, "analyses">>>;
+        getLatestAnalysis(input: import("./graphAnalysisClient").GetLatestGraphAnalysisInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
+        saveSuggestions(input: import("./graphAnalysisClient").SaveGraphSuggestionsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisSuggestionsResponse>>;
+        updateSuggestionStatus(input: import("./graphAnalysisClient").UpdateGraphSuggestionStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisSuggestion>>;
+        listSuggestions(input: import("./graphAnalysisClient").ListGraphSuggestionsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisSuggestion, "suggestions">>>;
+        listGraphChanges(input: import("./graphAnalysisClient").ListGraphChangesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisChangeRecord, "changes">>>;
+        computeOrRequestAnalysis(input: import("./graphAnalysisClient").ComputeOrRequestGraphAnalysisInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
+    };
+    graphRecommendations: {
+        listForTopic(input: import("./graphRecommendationsClient").GraphRecommendationListInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphRecommendationsClient").GraphRecommendationRecord, "recommendations">>>;
+        getRecommendation(recommendationId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphRecommendationsClient").GraphRecommendationRecord>>;
+        markRecommendationStatus(input: import("./graphRecommendationsClient").MarkGraphRecommendationStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphRecommendationsClient").GraphRecommendationRecord>>;
+    };
+    orgGraphSearch: {
+        search(input: import("./orgGraphSearchClient").OrgGraphSearchInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
+        getNode(input: import("./orgGraphSearchClient").GetOrgGraphNodeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResult>>;
+        listByProvenance(input: import("./orgGraphSearchClient").ListOrgGraphByProvenanceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
+        listPublishedFromWorkspace(input: import("./orgGraphSearchClient").ListPublishedFromWorkspaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
+    };
+    ontologyLinks: {
+        [methodName: string]: unknown;
+    };
+    graphStateClassifier: {
+        classifyNode(input: import("./graphStateClassifierClient").ClassifyNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphStateClassifierClient").GraphStateClassification>>;
+        classifyTopic(input: import("./graphStateClassifierClient").ClassifyTopicInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphStateClassifierClient").GraphStateClassification, "classifications">>>;
+        listClassifications(input: import("./graphStateClassifierClient").ListGraphStateClassificationsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphStateClassifierClient").GraphStateClassification, "classifications">>>;
+        recordClassification(input: import("./graphStateClassifierClient").RecordGraphStateClassificationInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphStateClassifierClient").GraphStateClassification>>;
+    };
+    modelRuntime: {
+        listModels(input: import("./modelRuntimeClient").ModelRuntimeScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./modelRuntimeClient").ModelRegistryRecord, "models">>>;
+        getModel(input: import("./modelRuntimeClient").ModelRuntimeScope & {
+            modelId: string;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelRegistryRecord>>;
+        listFunctionSlots(input: import("./modelRuntimeClient").ModelRuntimeScope & {
+            functionName?: string;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./modelRuntimeClient").ModelFunctionSlot, "slots">>>;
+        resolveSlot(input: import("./modelRuntimeClient").ResolveModelSlotInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelFunctionSlot>>;
+        updateSlotConfig(input: import("./modelRuntimeClient").UpdateModelSlotConfigInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelFunctionSlot>>;
+    };
+    jobs: {
+        enqueue(input: import("./jobsClient").EnqueueJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
+        list(input: import("./jobsClient").JobsScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./jobsClient").JobRecord, "jobs">>>;
+        claim(input: import("./jobsClient").ClaimJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
+        updateStatus(input: import("./jobsClient").UpdateJobStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
+        retry(input: import("./jobsClient").RetryJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
+        recordRunStart(input: import("./jobsClient").RecordJobRunStartInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRunRecord>>;
+        recordRunFinish(input: import("./jobsClient").RecordJobRunFinishInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRunRecord>>;
+    };
+    telemetry: {
+        logSystemEvent(input: import("./telemetry-client").LogSystemEventInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+            eventId?: string;
+            recorded: boolean;
+        }>>;
+        logToolCallsBatch(input: import("./telemetry-client").LogToolCallsBatchInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+            recorded: number;
+        }>>;
+        recordEpistemicAudit(input: import("./telemetry-client").RecordEpistemicAuditInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+            auditId?: string;
+            recorded: boolean;
+        }>>;
+        recordPolicyDecision(input: import("./telemetry-client").RecordTelemetryPolicyDecisionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+            decisionId?: string;
+            recorded: boolean;
+        }>>;
+        startRun(input: import("./telemetry-client").StartTelemetryRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./telemetry-client").TelemetryRunRecord>>;
+        finishRun(input: import("./telemetry-client").FinishTelemetryRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./telemetry-client").TelemetryRunRecord>>;
+        listRuns(input: import("./telemetry-client").TelemetryScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./telemetry-client").TelemetryRunRecord, "runs">>>;
+    };
+    publication: {
+        [methodName: string]: unknown;
+    };
+    contentPublication: {
+        [methodName: string]: unknown;
+    };
+    tools: {
+        listCatalog: (input: import("./toolRegistryClient").ToolRegistryQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
+        listExecutable: (input: import("./toolRegistryClient").ToolRegistryQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
+        listEffectiveTools: (input: import("./toolRegistryClient").EffectiveToolsQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
+        upsertCoreTools: (input: import("./toolRegistryClient").UpsertCoreToolsInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
+        setPackToolsStatus: (input: import("./toolRegistryClient").SetPackToolsStatusInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
+        createAcl: (input: import("./toolRegistryClient").CreateToolAclInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./toolRegistryClient").ToolAclRecord>>;
+        deleteAcl: (input: import("./toolRegistryClient").DeleteToolAclInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<{
+            aclId: string;
+            deleted: boolean;
+        }>>;
+        registerCustomTool: (input: import("./toolRegistryClient").RegisterCustomToolInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./toolRegistryClient").ToolCatalogEntry>>;
+        register: typeof registerCustomTool;
+        unregister: typeof unregisterCustomTool;
+        list: typeof listRegisteredCustomTools;
+        clear: typeof clearRegisteredCustomTools;
+        invoke(name: string, input?: import("./client-config").CustomToolInput): Promise<unknown>;
+        namespace: (namespace: string) => CustomToolNamespace;
+    };
+    packs: {
+        ensurePack: () => Promise<void>;
+        readonly isInstalled: boolean;
+        listCatalog: () => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
+        catalog: () => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
+        listStates: (query?: import("./coreClient").GatewayScope) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
+        states: (query?: import("./coreClient").GatewayScope) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
+        install: (input: import("./packsClient").PackInstallInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        enable: (input: import("./packsClient").PackEnableInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        disable: (input: import("./packsClient").PackDisableInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+    };
+    nodes: import("./client-assembly-types").ClientNodesNamespace;
+    controlPlane: {
+        identity: {
+            resolveInteractivePrincipal: (input: import("./control-plane").ResolveInteractivePrincipalInput) => Promise<import("./control-plane").ResolveInteractivePrincipalResponse>;
         };
-        graphRecommendations: {
-            listForTopic(input: import("./graphRecommendationsClient").GraphRecommendationListInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphRecommendationsClient").GraphRecommendationRecord, "recommendations">>>;
-            getRecommendation(recommendationId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphRecommendationsClient").GraphRecommendationRecord>>;
-            markRecommendationStatus(input: import("./graphRecommendationsClient").MarkGraphRecommendationStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphRecommendationsClient").GraphRecommendationRecord>>;
+        raw: {
+            identity: {
+                resolveInteractivePrincipal(input: import("./control-plane").ResolveInteractivePrincipalInput): Promise<import("./control-plane").ResolveInteractivePrincipalResponse>;
+            };
         };
-        graphStateClassifier: {
-            classifyNode(input: import("./graphStateClassifierClient").ClassifyNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphStateClassifierClient").GraphStateClassification>>;
-            classifyTopic(input: import("./graphStateClassifierClient").ClassifyTopicInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphStateClassifierClient").GraphStateClassification, "classifications">>>;
-            listClassifications(input: import("./graphStateClassifierClient").ListGraphStateClassificationsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphStateClassifierClient").GraphStateClassification, "classifications">>>;
-            recordClassification(input: import("./graphStateClassifierClient").RecordGraphStateClassificationInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphStateClassifierClient").GraphStateClassification>>;
+    };
+    identity: {
+        whoami(): Promise<{
+            authMode?: string;
+            clerkId?: string;
+            delegatedBy?: string;
+            expiresAt?: number;
+            groupIds?: string[];
+            isPlatformAdmin: boolean;
+            isTenantAdmin: boolean;
+            isWorkspaceAdmin: boolean;
+            permit?: {
+                subject: string;
+                tenant: string;
+                workspace?: string;
+            };
+            permittedPackKeys?: string[];
+            permittedToolNames?: string[];
+            principalId: string;
+            principalStatus?: string;
+            principalType: "user" | "human" | "service" | "group" | "external_viewer" | "agent";
+            roles: string[];
+            scopes: string[];
+            sessionId?: string;
+            tenantId: string | null;
+            tenantStatus?: string;
+            workspaceId: string | null;
+            workspaceStatus?: string;
+            correlationId: string;
+            data: import("./types").SdkPrincipalContext;
+            idempotentReplay: boolean;
+            policyTraceId: string | null;
+            success: true;
+        }>;
+        access: {
+            normalizePrincipal: typeof import("./accessControl").normalizeCanonicalPrincipalIdentity;
+            checkAccess: (input: import("./accessControl").RequireAccessInput, idempotencyKey?: string) => Promise<import("./accessControl").AccessCheckResult>;
+            requireAccess: (input: import("./accessControl").RequireAccessInput, idempotencyKey?: string) => Promise<import("./accessControl").AccessCheckResult>;
+            canAccess: (input: import("./accessControl").RequireAccessInput, idempotencyKey?: string) => Promise<boolean>;
         };
-        decisions: {
-            listJudgments(query: import("./decisionsClient").ListJudgmentsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListJudgmentsResponse>>;
-            getJudgment(judgmentId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GetJudgmentResponse>>;
-            getJudgmentReadiness(query: {
-                topicId?: string;
-            } & import("./types").TopicIdentifierInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentReadinessResponse>>;
+        resolveInteractivePrincipal: (input: import("./control-plane").ResolveInteractivePrincipalInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./control-plane").ResolvedInteractivePrincipalContext>>;
+        evaluatePolicy: (input: import("./identityClient").PolicyEvaluationInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").PolicyDecisionRecord>>;
+        recordPolicyDecision: (input: import("./identityClient").RecordPolicyDecisionInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").PolicyDecisionRecord>>;
+        putSecretReference: (input: import("./identityClient").PutTenantSecretReferenceInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").TenantSecretReference>>;
+        createPrincipal: (input: import("./coreClient").GatewayScope & {
+            principalId: string;
+            principalType: "user" | "group" | "service" | "external_viewer";
+            clerkId?: string;
+            email?: string;
+            displayName?: string;
+            status?: "active" | "invited" | "suspended" | "disabled" | "revoked";
+            metadata?: import("./types").JsonObject;
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        updatePrincipal: (input: import("./coreClient").GatewayScope & {
+            principalId: string;
+            principalType: "user" | "group" | "service" | "external_viewer";
+            clerkId?: string;
+            email?: string;
+            displayName?: string;
+            status?: "active" | "invited" | "suspended" | "disabled" | "revoked";
+            metadata?: import("./types").JsonObject;
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        raw: {
+            whoami(): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").SdkPrincipalContext>>;
+            resolveInteractivePrincipal(input: import("./control-plane").ResolveInteractivePrincipalInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./control-plane").ResolvedInteractivePrincipalContext>>;
+            listPrincipals(query?: import("./coreClient").GatewayScope & {
+                status?: string;
+                principalType?: string;
+                query?: string;
+                limit?: number;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "principals">>>;
+            createPrincipal(input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                principalType: "user" | "group" | "service" | "external_viewer";
+                clerkId?: string;
+                email?: string;
+                displayName?: string;
+                status?: "active" | "invited" | "suspended" | "disabled" | "revoked";
+                metadata?: import("./types").JsonObject;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            updatePrincipal: (input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                principalType: "user" | "group" | "service" | "external_viewer";
+                clerkId?: string;
+                email?: string;
+                displayName?: string;
+                status?: "active" | "invited" | "suspended" | "disabled" | "revoked";
+                metadata?: import("./types").JsonObject;
+            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            upsertPrincipal: (input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                principalType: "user" | "group" | "service" | "external_viewer";
+                clerkId?: string;
+                email?: string;
+                displayName?: string;
+                status?: "active" | "invited" | "suspended" | "disabled" | "revoked";
+                metadata?: import("./types").JsonObject;
+            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listKeys(query?: import("./coreClient").GatewayScope & {
+                principalId?: string;
+                status?: string;
+                limit?: number;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "keys">>>;
+            createKey(input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                keyId?: string;
+                token?: string;
+                scopes?: string[];
+                environment?: "sandbox" | "production";
+                expiresInDays?: number;
+                rateLimitTier?: "free" | "developer" | "partner";
+                metadata?: import("./types").JsonObject;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            rotateKey(keyId: string, input?: {
+                replacementKeyId?: string;
+                replacementToken?: string;
+                replacementExpiresInDays?: number;
+                gracePeriodHours?: number;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            deleteKey: (keyId: string, input?: {
+                reason?: string;
+            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            revokeKey: (keyId: string, input?: {
+                reason?: string;
+            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            searchClerkUsers(q: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").ClerkUserSearchResult[]>>;
+            getTenantConfig(input: import("./identityClient").TenantIdentityScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").TenantIdentityConfigRecord>>;
+            updateTenantConfig(input: import("./identityClient").UpdateTenantConfigInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").TenantIdentityConfigRecord>>;
+            listIntegrations(input: import("./identityClient").TenantIdentityScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./identityClient").TenantIntegrationRecord, "integrations">>>;
+            upsertIntegration(input: import("./identityClient").UpsertTenantIntegrationInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").TenantIntegrationRecord>>;
+            listSecrets(input: import("./identityClient").TenantIdentityScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./identityClient").TenantSecretReference, "secrets">>>;
+            putSecretReference(input: import("./identityClient").PutTenantSecretReferenceInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").TenantSecretReference>>;
+            evaluatePolicy(input: import("./identityClient").PolicyEvaluationInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").PolicyDecisionRecord>>;
+            recordPolicyDecision(input: import("./identityClient").RecordPolicyDecisionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./identityClient").PolicyDecisionRecord>>;
+        };
+    };
+    mcp: {
+        bootstrapSession: (input?: import("./mcpClient").McpBootstrapSessionInput) => Promise<import("./mcpClient").McpBootstrapSessionResponse>;
+        checkWritePolicy: (input: import("./mcpClient").McpCheckWritePolicyInput) => Promise<import("./mcpClient").McpCheckWritePolicyResponse>;
+        beginBuildSession: (input: import("./mcpClient").McpBeginBuildSessionInput) => Promise<import("./mcpClient").McpBeginBuildSessionResponse>;
+        evaluateEngineeringContract: (input: import("./mcpClient").McpEvaluateEngineeringContractInput) => Promise<import("./mcpClient").McpContractEvaluationResponse>;
+        evaluateResearchContract: (input: import("./mcpClient").McpEvaluateResearchContractInput) => Promise<import("./mcpClient").McpContractEvaluationResponse>;
+    };
+    auth: {
+        device: {
+            createCode: (input?: import("./authDeviceClient").DeviceCodeInput) => Promise<import("./authDeviceClient").DeviceCodeResponse>;
+            pollToken: (deviceCode: string) => Promise<import("./authDeviceClient").DeviceTokenResponse>;
+        };
+    };
+    custom: CustomToolNamespace;
+    extensions: Record<string, CustomToolNamespace>;
+    raw: {
+        beliefs: {
+            createBelief(input: import("./beliefsClient").CreateBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
+            refineBelief(beliefId: string, input: import("./beliefsClient").RefineBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
+            getOpinionHistory: (beliefId: string) => Promise<import("./beliefsClient").OpinionHistoryEntry[]>;
+            getConfidenceHistory: (beliefId: string) => Promise<import("./beliefsClient").OpinionHistoryEntry[]>;
+            forkBelief(beliefId: string, input: import("./beliefsClient").ForkBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ForkBeliefResponse>>;
+            updateBeliefRationale(input: import("./beliefsClient").UpdateBeliefRationaleInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            linkBeliefs(input: import("./beliefsClient").LinkBeliefsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            unlinkBeliefEvidence(input: import("./beliefsClient").UnlinkBeliefEvidenceInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            updateBeliefCriticality(input: import("./beliefsClient").UpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            batchUpdateBeliefCriticality(input: import("./beliefsClient").BatchUpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            reassignBeliefsTopic(input: import("./beliefsClient").ReassignBeliefsTopicInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+        sources: {
+            upsert(spec: import("./sources-client").UpsertSourceSpec, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformSourceRecord>>;
+            get(sourceId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformSourceRecord>>;
+        };
+        evidence: {
+            classifyEvidence(beliefId: string, evidenceId: string, classificationConfig?: import("./evidenceClient").EvidenceClassificationRequestConfig, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./evidenceClient").ClassifyEvidenceResult>>;
+            classifyEvidenceBatch(beliefId: string, evidence: import("./evidenceClient").ClassifyEvidenceBatchItem[], classificationConfig?: import("./evidenceClient").EvidenceClassificationRequestConfig, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./evidenceClient").ClassifyEvidenceBatchResult>>;
+        };
+        embeddings: {
+            getByNodeIds(input: import("./embeddingsClient").GetEmbeddingsByNodeIdsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").EmbeddingRecord, "embeddings">>>;
+            listMissingForTopic(input: import("./embeddingsClient").ListMissingEmbeddingsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").MissingEmbeddingCandidate, "nodes">>>;
+            vectorSearchByTopic(input: import("./embeddingsClient").VectorSearchByTopicInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./embeddingsClient").VectorSearchMatch, "results">>>;
+            markEmbeddingBackfillQueued(input: import("./embeddingsClient").MarkEmbeddingBackfillQueuedInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+                queued: number;
+                topicId: string;
+                workspaceId: string;
+                nodeIds: string[];
+            }>>;
+        };
+        eventing: {
+            recordEvent(input: import("./eventingClient").RecordEventInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingRecord>>;
+            listEvents(input: import("./eventingClient").EventingScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./eventingClient").EventingRecord, "events">>>;
+            listWebhooks(input: import("./eventingClient").EventingScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./eventingClient").EventingWebhookRecord, "webhooks">>>;
+            enqueueDelivery(input: import("./eventingClient").EnqueueDeliveryInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
+            recordDeliveryAttempt(input: import("./eventingClient").RecordDeliveryAttemptInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
+            updateDeliveryStatus(input: import("./eventingClient").UpdateDeliveryStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
+        };
+        graph: {
+            listNodes(query: import("./graphClient").ListNodesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PlatformGraphNode, "nodes">>>;
+            getNode(query: import("./graphClient").GetNodeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformGraphNode>>;
+            createNode(input: import("./graphClient").CreateNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformGraphNode>>;
+            updateNode(input: import("./graphClient").UpdateNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformGraphNode>>;
+            batchCreateNodes(input: import("./graphClient").BatchCreateNodesInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            supersedeNode(input: import("./graphClient").SupersedeNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            verifyNode(input: import("./graphClient").VerifyNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            hardDeleteNode(input: import("./graphClient").HardDeleteNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            listEdges(query: import("./graphClient").ListEdgesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PlatformGraphEdge, "edges">>>;
+            createEdge(input: import("./graphClient").CreateEdgeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformGraphEdge>>;
+            deleteEdge(query: import("./graphClient").DeleteEdgeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").DeleteEdgeResponse>>;
+            neighborhood(query: import("./graphClient").NeighborhoodInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>;
+            traverse(query: import("./graphClient").TraverseInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            analyze(query?: import("./graphClient").AnalyzeInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            bias(query?: import("./graphClient").BiasInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            gaps(query: import("./graphClient").GapsInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            search(query: import("./graphClient").SearchInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            getPath(query: import("./graphClient").PathInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GraphPathResponse>>;
+            getAnalytics(query?: import("./graphClient").AnalyticsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GraphAnalyticsResponse<import("./types").GraphAnalyticsMetric>>>;
+        } & {
+            queryNodes: (query: import("./graphClient").ListNodesInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PlatformGraphNode, "nodes">>>;
+            queryEdges: (query: import("./graphClient").ListEdgesInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PlatformGraphEdge, "edges">>>;
+            getNeighborhood: (query: import("./graphClient").NeighborhoodInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>;
+        };
+        graphAnalysis: {
+            listGraphIntelligenceQueries(input?: import("./graphAnalysisClient").ListGraphIntelligenceQueriesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphIntelligenceQueryCatalogResponse>>;
+            runGraphIntelligenceQuery(input: import("./graphAnalysisClient").RunGraphIntelligenceQueryInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphIntelligenceQueryRunResponse>>;
+            saveAnalysis(input: import("./graphAnalysisClient").SaveGraphAnalysisInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
+            listAnalyses(input: import("./graphAnalysisClient").ListGraphAnalysesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisRecord, "analyses">>>;
+            getLatestAnalysis(input: import("./graphAnalysisClient").GetLatestGraphAnalysisInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
+            saveSuggestions(input: import("./graphAnalysisClient").SaveGraphSuggestionsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisSuggestionsResponse>>;
+            updateSuggestionStatus(input: import("./graphAnalysisClient").UpdateGraphSuggestionStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisSuggestion>>;
+            listSuggestions(input: import("./graphAnalysisClient").ListGraphSuggestionsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisSuggestion, "suggestions">>>;
+            listGraphChanges(input: import("./graphAnalysisClient").ListGraphChangesInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphAnalysisClient").GraphAnalysisChangeRecord, "changes">>>;
+            computeOrRequestAnalysis(input: import("./graphAnalysisClient").ComputeOrRequestGraphAnalysisInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphAnalysisClient").GraphAnalysisRecord>>;
+        };
+        graphRecommendations: {
+            listForTopic(input: import("./graphRecommendationsClient").GraphRecommendationListInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphRecommendationsClient").GraphRecommendationRecord, "recommendations">>>;
+            getRecommendation(recommendationId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphRecommendationsClient").GraphRecommendationRecord>>;
+            markRecommendationStatus(input: import("./graphRecommendationsClient").MarkGraphRecommendationStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphRecommendationsClient").GraphRecommendationRecord>>;
+        };
+        graphStateClassifier: {
+            classifyNode(input: import("./graphStateClassifierClient").ClassifyNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphStateClassifierClient").GraphStateClassification>>;
+            classifyTopic(input: import("./graphStateClassifierClient").ClassifyTopicInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphStateClassifierClient").GraphStateClassification, "classifications">>>;
+            listClassifications(input: import("./graphStateClassifierClient").ListGraphStateClassificationsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./graphStateClassifierClient").GraphStateClassification, "classifications">>>;
+            recordClassification(input: import("./graphStateClassifierClient").RecordGraphStateClassificationInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./graphStateClassifierClient").GraphStateClassification>>;
+        };
+        decisions: {
+            listJudgments(query: import("./decisionsClient").ListJudgmentsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListJudgmentsResponse>>;
+            getJudgment(judgmentId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GetJudgmentResponse>>;
+            getJudgmentReadiness(query: {
+                topicId?: string;
+            } & import("./types").TopicIdentifierInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentReadinessResponse>>;
             getJudgmentCalibration(query: import("./decisionsClient").GetJudgmentCalibrationInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentCalibrationResponse>>;
             listPendingOutcomeReviews(query: import("./decisionsClient").ListPendingJudgmentOutcomeReviewInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PendingJudgmentOutcomeRecord, "reviews">>>;
             getJudgmentTransitionAuditIntegrity(query: import("./decisionsClient").GetJudgmentTransitionAuditIntegrityInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentTransitionAuditIntegrityResponse>>;
@@ -808,65 +1136,65 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             listTenantApiKeys(scope: import("./coreClient").GatewayScope & {
                 status?: "active" | "revoked" | "expired";
             }): Promise<{
-                data: {
-                    keys: import("./adminClient").TenantApiKeyRecord[];
-                };
                 correlationId: string;
                 idempotentReplay: boolean;
                 policyTraceId: string | null;
                 success: true;
+                data: {
+                    keys: import("./adminClient").TenantApiKeyRecord[];
+                };
             }>;
             createTenantApiKey(input: import("./coreClient").GatewayScope & {
                 label?: string;
                 scopes: string[];
                 expiresAt?: number;
             }, idempotencyKey?: string): Promise<{
-                data: {
-                    key: import("./adminClient").TenantApiKeyRecord | null;
-                    plaintextKey: string | undefined;
-                };
                 correlationId: string;
                 idempotentReplay: boolean;
                 policyTraceId: string | null;
                 success: true;
+                data: {
+                    key: import("./adminClient").TenantApiKeyRecord | null;
+                    plaintextKey: string | undefined;
+                };
             }>;
             revokeTenantApiKey(keyId: string, input?: import("./coreClient").GatewayScope & {
                 reason?: string;
             }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
             listTenantVaultSecrets(scope: import("./coreClient").GatewayScope): Promise<{
-                data: {
-                    secrets: import("./adminClient").TenantVaultSecretRecord[];
-                };
                 correlationId: string;
                 idempotentReplay: boolean;
                 policyTraceId: string | null;
                 success: true;
+                data: {
+                    secrets: import("./adminClient").TenantVaultSecretRecord[];
+                };
             }>;
             createTenantVaultSecret(input: import("./coreClient").GatewayScope & {
                 name: string;
                 description?: string;
                 value: string;
             }, idempotencyKey?: string): Promise<{
-                data: {
-                    secret: import("./adminClient").TenantVaultSecretRecord | null;
-                };
                 correlationId: string;
                 idempotentReplay: boolean;
                 policyTraceId: string | null;
                 success: true;
+                data: {
+                    secret: import("./adminClient").TenantVaultSecretRecord | null;
+                };
             }>;
             updateTenantVaultSecret(secretId: string, input: import("./coreClient").GatewayScope & {
                 name: string;
                 description?: string;
                 value?: string;
             }, idempotencyKey?: string): Promise<{
-                data: {
-                    secret: import("./adminClient").TenantVaultSecretRecord | null;
-                };
                 correlationId: string;
                 idempotentReplay: boolean;
                 policyTraceId: string | null;
                 success: true;
+                data: {
+                    secret: import("./adminClient").TenantVaultSecretRecord | null;
+                };
             }>;
             deleteTenantVaultSecret(secretId: string, scope: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
             listTenantSecrets(scope: import("./coreClient").GatewayScope & {
@@ -1036,48 +1364,48 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 toolCategory?: string;
                 enabled?: boolean;
             }): Promise<{
+                correlationId: string;
+                idempotentReplay: boolean;
+                policyTraceId: string | null;
+                success: true;
                 data: {
                     policies: import("./policyClient").WritePolicyRecord[];
                 };
+            }>;
+            createWritePolicy(input: import("./policyClient").WritePolicyCreateInput, idempotencyKey?: string): Promise<{
                 correlationId: string;
                 idempotentReplay: boolean;
                 policyTraceId: string | null;
                 success: true;
-            }>;
-            createWritePolicy(input: import("./policyClient").WritePolicyCreateInput, idempotencyKey?: string): Promise<{
                 data: {
                     id: string | undefined;
                     created: boolean;
                     policy: import("./policyClient").WritePolicyRecord | null;
                 };
+            }>;
+            updateWritePolicy(id: string, input: import("./policyClient").WritePolicyUpdateInput, idempotencyKey?: string): Promise<{
                 correlationId: string;
                 idempotentReplay: boolean;
                 policyTraceId: string | null;
                 success: true;
-            }>;
-            updateWritePolicy(id: string, input: import("./policyClient").WritePolicyUpdateInput, idempotencyKey?: string): Promise<{
                 data: {
                     id: string | undefined;
                     updated: boolean;
                     policy: import("./policyClient").WritePolicyRecord | null;
                 };
-                correlationId: string;
-                idempotentReplay: boolean;
-                policyTraceId: string | null;
-                success: true;
             }>;
             deleteWritePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
                 id?: string;
                 deleted?: boolean;
             }>>;
             listRolePolicies(query?: import("./coreClient").GatewayScope): Promise<{
-                data: {
-                    policies: import("./policyClient").TenantPolicyRecord[];
-                };
                 correlationId: string;
                 idempotentReplay: boolean;
                 policyTraceId: string | null;
                 success: true;
+                data: {
+                    policies: import("./policyClient").TenantPolicyRecord[];
+                };
             }>;
             createRolePolicy(input: import("./coreClient").GatewayScope & import("./policyClient").TenantPolicyClassificationFields & {
                 roleName: string;
@@ -1085,13 +1413,13 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 permissions: import("./policyClient").TenantPolicyPermission[];
                 groupBindings?: string[];
             }, idempotencyKey?: string): Promise<{
-                data: {
-                    policy: import("./policyClient").TenantPolicyRecord | null;
-                };
                 correlationId: string;
                 idempotentReplay: boolean;
                 policyTraceId: string | null;
                 success: true;
+                data: {
+                    policy: import("./policyClient").TenantPolicyRecord | null;
+                };
             }>;
             updateRolePolicy(id: string, input: import("./coreClient").GatewayScope & import("./policyClient").TenantPolicyClassificationFields & {
                 roleName: string;
@@ -1099,1076 +1427,747 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 permissions: import("./policyClient").TenantPolicyPermission[];
                 groupBindings?: string[];
             }, idempotencyKey?: string): Promise<{
-                data: {
-                    policy: import("./policyClient").TenantPolicyRecord | null;
-                };
                 correlationId: string;
                 idempotentReplay: boolean;
                 policyTraceId: string | null;
                 success: true;
-            }>;
-            deleteRolePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            checkPermission(query: import("./coreClient").GatewayScope & {
-                topicId?: string;
-                permission?: import("./policyClient").PermissionKind;
-                principal?: string;
-                principalId?: string;
-                beliefClusterId?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./policyClient").PermissionDecision>>;
-            listAccessibleTopics(query?: import("./coreClient").GatewayScope & {
-                permission?: import("./policyClient").PermissionKind;
-                includeShared?: boolean;
-                principal?: string;
-                principalId?: string;
-                limit?: number;
-            }): Promise<{
                 data: {
-                    permission: import("./policyClient").PermissionKind;
-                    topics: import("./policyClient").PolicyTopicRecord[];
-                    total: number;
-                    deniedTopics: {
-                        topicId: string;
-                        reasonCode: string;
-                    }[];
+                    policy: import("./policyClient").TenantPolicyRecord | null;
                 };
-                correlationId: string;
-                idempotentReplay: boolean;
-                policyTraceId: string | null;
-                success: true;
-            }>;
-            filterByPermission(input: import("./coreClient").GatewayScope & {
-                topicIds?: string[];
-                permission?: import("./policyClient").PermissionKind;
-                principal?: string;
-                principalId?: string;
-            }): Promise<{
-                success: true;
-                data: import("./policyClient").FilterByPermissionResponse;
-            }>;
-        };
-        answers: {
-            get(questionId: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-        };
-        ontology: {
-            list(filters?: import("./coreClient").GatewayScope & {
-                tenantId?: string;
-                tier?: string;
-                status?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<{
-                ontologies: unknown[];
-                total: number;
-                items: unknown[];
-                definitions: unknown[];
-            }>>;
-            get(id: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            bind(input: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            createDefinition(input: import("./ontologyClient").OntologyDefinitionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            updateDefinition(id: string, input: import("./ontologyClient").OntologyDefinitionUpdateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            archiveDefinition(id: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listVersions(ontologyId: string, filters?: import("./coreClient").GatewayScope & {
-                status?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<unknown, "versions">>>;
-            createVersion(ontologyId: string, input: import("./ontologyClient").OntologyVersionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            publishVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            deprecateVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listTopics(ontologyId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "topics">>>;
-        } & {
-            listDefinitions: (filters?: import("./coreClient").GatewayScope & {
-                tenantId?: string;
-                tier?: string;
-                status?: string;
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<{
-                ontologies: unknown[];
-                total: number;
-                items: unknown[];
-                definitions: unknown[];
-            }>>;
-            getDefinition: (id: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listTopicsByOntology: (ontologyId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "topics">>>;
-        };
-        ontologyLinks: {
-            createLink(input: import("./ontologyLinksClient").OntologyLinkWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./ontologyLinksClient").OntologyLinkRecord>>;
-            upsertLink(input: import("./ontologyLinksClient").OntologyLinkWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./ontologyLinksClient").OntologyLinkRecord>>;
-            listLinksForNode(input: import("./ontologyLinksClient").ListOntologyLinksForNodeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./ontologyLinksClient").OntologyLinkRecord, "links">>>;
-            updateLinkStatus(input: import("./ontologyLinksClient").UpdateOntologyLinkStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./ontologyLinksClient").OntologyLinkRecord>>;
-        };
-        orgGraphSearch: {
-            search(input: import("./orgGraphSearchClient").OrgGraphSearchInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
-            getNode(input: import("./orgGraphSearchClient").GetOrgGraphNodeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResult>>;
-            listByProvenance(input: import("./orgGraphSearchClient").ListOrgGraphByProvenanceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
-            listPublishedFromWorkspace(input: import("./orgGraphSearchClient").ListPublishedFromWorkspaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
-        };
-        functionSurface: {
-            sessionId: string;
-            activateWorktree(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            addEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            addWorktree(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            analyzeGraphImpact(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            analyzeTopicDensity(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            answerQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            appendSlScoring(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            applyAutoBranching(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            applyLensToTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            applyOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            archiveBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            archiveEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            archiveEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            archiveOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            archiveQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            batchCreateEdges(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            batchCreateEpistemicNodes(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            beginBuildSession(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            bisectConfidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            broadcastMessage(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            checkPermission(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            claimFiles(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            compileCapabilitySlice(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            compileContext(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            completeTask(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createAnswer(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createEdge(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createEpistemicContract(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createLens(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createOntologyVersion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createTask(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            createTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            deprecateOntologyVersion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            detectConfirmationBias(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            detectGraphDrift(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            discover(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            discoverEntityConnections(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            endSession(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            evaluateContract(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            expandGraphNeighborhood(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            expandNarrative(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            filterByPermission(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            findContradictions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            findMissingQuestions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            findRelatedNodes(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            flagContradiction(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            forkBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            generateSessionHandoff(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getAgentInbox(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getAnswer(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getAuditTrail(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getCampaignContext(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getChangeHistory(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getCodeContext(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getConfidenceHistory(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getContractStatus(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getByNodeIds(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getFailureLog(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getFalsificationQuestions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getGraphGaps(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getGraphNeighborhood(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getGraphStructureAnalysis(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getHighPriorityQuestions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getLatticeCoverage(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getLoadBearingNodes(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getObservationContext(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getOperatorGauntlet(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getReasoningExemplars(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getTopicCoverage(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getTopicGraphSpine(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getTopicTree(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            getWorktree(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            heartbeatSession(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            hybridDiscover(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            whoami(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            ingestObservation(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            linkEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            linkEvidenceToBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            linkEvidenceToQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listActiveSessions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listAllWorktrees(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listBeliefs(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listCampaigns(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listEpistemicNodes(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listGraphIntelligenceQueries(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listLenses(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listMissingForTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listOntologies(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listQuestions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listTasks(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listTopics(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listWorktrees(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            listWorktreesByBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            lucernOrient(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            manageWritePolicy(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            matchEntityType(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            materializeTopicGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            merge(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            openPullRequest(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            pipelineSnapshot(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            publishOntologyVersion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            push(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            queryAnchorHistory(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            queryLineage(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            markEmbeddingBackfillQueued(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            recordAttempt(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            recordJudgment(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            recordScopeLearning(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            refineBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            refineQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            registerSession(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            removeEdge(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            removeEdgesBetween(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            removeLensFromTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            resolveEffectiveOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            resolveInteractivePrincipal(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            resolveTopicSemantic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            runGraphIntelligenceQuery(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            searchBeliefs(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            vectorSearchByTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            searchEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            seedBeliefLattice(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            sendAgentMessage(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            supersedeEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            traceEntityImpact(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            traverseGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            triggerBeliefReview(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            updateEdge(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            updateEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            updateOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            updateQuestionStatus(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            updateTask(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            updateTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            updateWorktreeMetadata(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            updateWorktreeTargets(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-            verifyEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-        };
-        controlPlane: {
-            identity: {
-                resolveInteractivePrincipal(input: import("./control-plane").ResolveInteractivePrincipalInput): Promise<import("./control-plane").ResolveInteractivePrincipalResponse>;
-            };
-        };
-        toolRegistry: {
-            listCatalog(input: import("./toolRegistryClient").ToolRegistryQuery): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
-            listExecutable(input: import("./toolRegistryClient").ToolRegistryQuery): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
-            listEffectiveTools(input: import("./toolRegistryClient").EffectiveToolsQuery): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
-            upsertCoreTools(input: import("./toolRegistryClient").UpsertCoreToolsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
-            setPackToolsStatus(input: import("./toolRegistryClient").SetPackToolsStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
-            createAcl(input: import("./toolRegistryClient").CreateToolAclInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./toolRegistryClient").ToolAclRecord>>;
-            deleteAcl(input: import("./toolRegistryClient").DeleteToolAclInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-                aclId: string;
-                deleted: boolean;
-            }>>;
-            registerCustomTool(input: import("./toolRegistryClient").RegisterCustomToolInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./toolRegistryClient").ToolCatalogEntry>>;
-        };
-        modelRuntime: {
-            listModels(input: import("./modelRuntimeClient").ModelRuntimeScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./modelRuntimeClient").ModelRegistryRecord, "models">>>;
-            getModel(input: import("./modelRuntimeClient").ModelRuntimeScope & {
-                modelId: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelRegistryRecord>>;
-            listFunctionSlots(input: import("./modelRuntimeClient").ModelRuntimeScope & {
-                functionName?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./modelRuntimeClient").ModelFunctionSlot, "slots">>>;
-            resolveSlot(input: import("./modelRuntimeClient").ResolveModelSlotInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelFunctionSlot>>;
-            updateSlotConfig(input: import("./modelRuntimeClient").UpdateModelSlotConfigInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelFunctionSlot>>;
-        };
-        packs: {
-            listCatalog(): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
-            getDiscoveryCatalog(): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            getDiscoveryDetail(packKey: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listStates(query?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
-            getHealth(packKey: string, query?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listTelemetry(query?: import("./coreClient").GatewayScope & {
-                lookbackHours?: number;
-                limit?: number;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "telemetry">>>;
-            createEntitlement(input: import("./packsClient").PackEntitlementInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            install(input: import("./packsClient").PackInstallInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            enable(input: import("./packsClient").PackEnableInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            disable(input: import("./packsClient").PackDisableInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            uninstall(input: import("./packsClient").PackUninstallInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            upgrade(input: import("./packsClient").PackUpgradeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-        } & {
-            getCatalog: () => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
-            getStates: (query?: import("./coreClient").GatewayScope) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
-            getTelemetry: (query?: import("./coreClient").GatewayScope & {
-                lookbackHours?: number;
-                limit?: number;
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "telemetry">>>;
-            updateEntitlement: (input: import("./packsClient").PackEntitlementInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            upsertEntitlement: (input: import("./packsClient").PackEntitlementInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-        };
-        reports: {
-            listTemplates: (args?: {
-                slug?: string;
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ReportTemplatesResponse>>;
-            getTemplates: (args?: {
-                slug?: string;
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ReportTemplatesResponse>>;
-            listReports: (input: import("./types").TopicIdentifierInput, args?: {
-                summary?: boolean;
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "reports">>>;
-            getReport: (reportId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ReportWithSectionsResponse>>;
-        };
-        learning: {
-            listRecentExecutions: (args?: {
-                namespace?: string;
-                topicId?: string;
-                audienceMode?: string;
-                success?: boolean;
-                limit?: number;
-            } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "executions">>>;
-            getRecentExecutions: (args?: {
-                namespace?: string;
-                topicId?: string;
-                audienceMode?: string;
-                success?: boolean;
-                limit?: number;
-            } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "executions">>>;
-            getExecutionStats: (args?: {
-                namespace?: string;
-                topicId?: string;
-                audienceMode?: string;
-                hours?: number;
-            } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-        };
-        mcp: {
-            bootstrapSession(input?: import("./mcpClient").McpBootstrapSessionInput): Promise<import("./mcpClient").McpBootstrapSessionResponse>;
-            checkWritePolicy(input: import("./mcpClient").McpCheckWritePolicyInput): Promise<import("./mcpClient").McpCheckWritePolicyResponse>;
-            beginBuildSession(input: import("./mcpClient").McpBeginBuildSessionInput): Promise<import("./mcpClient").McpBeginBuildSessionResponse>;
-            evaluateEngineeringContract(input: import("./mcpClient").McpEvaluateEngineeringContractInput): Promise<import("./mcpClient").McpContractEvaluationResponse>;
-            evaluateResearchContract(input: import("./mcpClient").McpEvaluateResearchContractInput): Promise<import("./mcpClient").McpContractEvaluationResponse>;
-        };
-        jobs: {
-            enqueue(input: import("./jobsClient").EnqueueJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
-            list(input: import("./jobsClient").JobsScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./jobsClient").JobRecord, "jobs">>>;
-            claim(input: import("./jobsClient").ClaimJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
-            updateStatus(input: import("./jobsClient").UpdateJobStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
-            retry(input: import("./jobsClient").RetryJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
-            recordRunStart(input: import("./jobsClient").RecordJobRunStartInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRunRecord>>;
-            recordRunFinish(input: import("./jobsClient").RecordJobRunFinishInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRunRecord>>;
-        };
-        telemetry: {
-            logSystemEvent(input: import("./telemetry-client").LogSystemEventInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-                eventId?: string;
-                recorded: boolean;
-            }>>;
-            logToolCallsBatch(input: import("./telemetry-client").LogToolCallsBatchInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-                recorded: number;
-            }>>;
-            recordEpistemicAudit(input: import("./telemetry-client").RecordEpistemicAuditInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-                auditId?: string;
-                recorded: boolean;
-            }>>;
-            recordPolicyDecision(input: import("./telemetry-client").RecordTelemetryPolicyDecisionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
-                decisionId?: string;
-                recorded: boolean;
-            }>>;
-            startRun(input: import("./telemetry-client").StartTelemetryRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./telemetry-client").TelemetryRunRecord>>;
-            finishRun(input: import("./telemetry-client").FinishTelemetryRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./telemetry-client").TelemetryRunRecord>>;
-            listRuns(input: import("./telemetry-client").TelemetryScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./telemetry-client").TelemetryRunRecord, "runs">>>;
-        };
-        harness: {
-            listAgentDefinitions(scope?: import("./coreClient").GatewayScope & {
-                status?: string;
-                limit?: number;
-                cursor?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "agents">>>;
-            getAgentDefinition(agentId: string, scope?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            createAgentDefinition(input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            updateAgentDefinition(agentId: string, input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            invokeManagedAgentDefinition(agentId: string, input: Omit<import("./harnessClient").HarnessInvokeManagedAgentInput, "agentDefinitionId">, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listAgentRuns(agentId: string, scope?: import("./coreClient").GatewayScope & {
-                status?: string;
-                limit?: number;
-                cursor?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
-            listToolDefinitions(scope?: import("./coreClient").GatewayScope & {
-                status?: string;
-                limit?: number;
-                cursor?: string;
-                gateClassification?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "tools">>>;
-            getToolDefinition(toolId: string, scope?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            createToolDefinition(input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            updateToolDefinition(toolId: string, input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            executeToolDefinition(toolId: string, input?: import("./harnessClient").HarnessExecuteToolInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./harnessClient").HarnessExecuteToolResult>>;
-            listRunEntries(scope?: import("./coreClient").GatewayScope & {
-                status?: string;
-                limit?: number;
-                cursor?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
-            startHarnessRun(input: import("./harnessClient").HarnessStartRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            getRunLedgerEntry(runId: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            reportHarnessRunEvent(runId: string, input: import("./harnessClient").HarnessRunReportInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            heartbeatHarnessRun(runId: string, input: {
-                reportingToken: string;
-            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            completeHarnessRun(runId: string, input: import("./harnessClient").HarnessCompleteRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listPromptResolutions(query?: {
-                runId?: string;
-                promptName?: string;
-                limit?: number;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "prompts">>>;
-            getScopeTaxonomy(): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-        } & {
-            registerAgentDefinition: (input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listRunsForAgent: (agentId: string, scope?: import("./coreClient").GatewayScope & {
-                status?: string;
-                limit?: number;
-                cursor?: string;
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
-            registerToolDefinition: (input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listRunLedgerEntries: (scope?: import("./coreClient").GatewayScope & {
-                status?: string;
-                limit?: number;
-                cursor?: string;
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
-        };
-        schema: {
-            listPacks(scope?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "packs">>>;
-            installPack(input: import("./schema-client").SchemaPackInstallInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            getPack(packId: string, scope?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listEntitlements(scope?: import("./coreClient").GatewayScope & {
-                packKey?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "entitlements">>>;
-            createEntitlement: (input: import("./schema-client").SchemaEntitlementInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            updateEntitlement: (input: import("./schema-client").SchemaEntitlementInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            upsertEntitlement: (input: import("./schema-client").SchemaEntitlementInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-        };
-        audiences: {
-            listRegistry: (query?: import("./coreClient").GatewayScope & {
-                effective?: boolean;
-                status?: "active" | "disabled" | "archived";
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "registryEntries">>>;
-            getRegistry: (query?: import("./coreClient").GatewayScope & {
-                effective?: boolean;
-                status?: "active" | "disabled" | "archived";
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "registryEntries">>>;
-            createRegistryEntry: (input: import("./audiences-client").AudienceRegistryInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            updateRegistryEntry: (input: import("./audiences-client").AudienceRegistryInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            upsertRegistry: (input: import("./audiences-client").AudienceRegistryInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listGrants: (query?: import("./coreClient").GatewayScope & {
-                audienceKey?: string;
-                principalId?: string;
-                groupId?: string;
-                status?: "active" | "revoked" | "expired";
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "grants">>>;
-            getGrants: (query?: import("./coreClient").GatewayScope & {
-                audienceKey?: string;
-                principalId?: string;
-                groupId?: string;
-                status?: "active" | "revoked" | "expired";
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "grants">>>;
-            createGrant: (input: import("./audiences-client").AudienceGrantInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            grant: (input: import("./audiences-client").AudienceGrantInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            deleteGrant: (input: import("./audiences-client").AudienceGrantRevokeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            revokeGrant: (input: import("./audiences-client").AudienceGrantRevokeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-        };
-        topics: {
-            list(query?: import("./topicsClient").TopicListInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicListResponse>>;
-            get(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>;
-            create(input: import("./topicsClient").TopicCreateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>;
-            update(topicId: string, input: import("./topicsClient").TopicUpdateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>;
-            getTree(topicId: string, query?: import("./topicsClient").TopicTreeQuery): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicTreeResponse>>;
-            getCoverage(topicId: string, query?: import("./topicsClient").TopicCoverageQuery): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>;
-            remove(topicId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-            bulkCreate(input: import("./topicsClient").TopicBulkCreateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-        };
-    };
-    judgments: {
-        create: (input: import("./decisionsClient").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
-        record: (input: import("./decisionsClient").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
-        list: (query: import("./decisionsClient").ListJudgmentsInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListJudgmentsResponse>>;
-        get: (judgmentId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GetJudgmentResponse>>;
-        recordOutcome: (judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
-        updateOutcome: (judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
-        readiness(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentReadinessResponse>>;
-        calibration(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentCalibrationResponse>>;
-        pendingOutcomeReview(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PendingJudgmentOutcomeRecord, "reviews">>>;
-        transitionAuditIntegrity(args: {
-            topicId?: string;
-            judgmentId?: string;
-            includePassing?: boolean;
-        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentTransitionAuditIntegrityResponse>>;
-    };
-    decisions: {
-        create: (input: import("./decisionsClient").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
-        record: (input: import("./decisionsClient").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
-        list: (query: import("./decisionsClient").ListJudgmentsInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListJudgmentsResponse>>;
-        get: (judgmentId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GetJudgmentResponse>>;
-        recordOutcome: (judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
-        lessons(decisionId: string, input: import("./types").JsonObject, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-        archive(decisionId: string, input?: import("./types").JsonObject, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-        readiness(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentReadinessResponse>>;
-        calibration(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentCalibrationResponse>>;
-        pendingOutcomeReview(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PendingJudgmentOutcomeRecord, "reviews">>>;
-    };
-    worktrees: {
-        createBranch: (input: {
-            name: string;
-            topicId?: string;
-            description?: string;
-            metadata?: import("./types").JsonObject;
-        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowBranchRecord>>;
-        createLens: (input: {
-            name: string;
-            workspaceId?: string;
-            topicId?: string;
-            description?: string;
-            perspectiveType: import("./workflowClient").WorkflowLensPerspectiveType;
-            promptTemplates?: import(".").LensPromptTemplateReference[];
-            workflowTemplates?: import(".").LensWorkflowTemplate[];
-            taskTemplates?: import(".").LensTaskTemplate[];
-            questionTemplates?: import(".").LensQuestionTemplate[];
-            filterCriteria?: import("./types").JsonObject;
-        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowLensRecord>>;
-        listLenses: (query: {
-            workspaceId?: string;
-            topicId?: string;
-            status?: import("./workflowClient").WorkflowLensStatus;
-            perspectiveType?: import("./workflowClient").WorkflowLensPerspectiveType;
-        } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowLensRecord, "lenses">>>;
-        applyLensToTopic: (input: {
-            lensId: string;
-            topicId?: string;
-            metadata?: import("./types").JsonObject;
-        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>;
-        removeLensFromTopic: (input: {
-            lensId: string;
-            topicId?: string;
-        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>;
-        create(input: import("./workflowClient").AddWorktreeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        add(input: import("./workflowClient").AddWorktreeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        list(query: Parameters<(query: {
-            topicId?: string;
-            branchId?: string;
-            status?: import("./workflowClient").WorkflowWorktreeStatus;
-            groupBy?: "campaign" | "lane" | "flat";
-            lane?: string;
-            campaign?: number;
-            limit?: number;
-        } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowWorktreeRecord, "worktrees">>>>[0]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").WorktreesListResult>>;
-        listByTopic(query: Parameters<(query: {
-            topicId?: string;
-            branchId?: string;
-            status?: import("./workflowClient").WorkflowWorktreeStatus;
-            groupBy?: "campaign" | "lane" | "flat";
-            lane?: string;
-            campaign?: number;
-            limit?: number;
-        } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowWorktreeRecord, "worktrees">>>>[0]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").WorktreesListResult>>;
-        findByPairedSprint(input: {
-            sprintId: string;
-            topicId?: string;
-            projectId?: string;
-            limit?: number;
-        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-        activate(worktreeId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        updateMetadata(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        update(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        updateTargets(input: Parameters<(input: import("./workflowClient").UpdateWorktreeTargetsInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>>[0]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        listAll: (query?: {
-            status?: import("./workflowClient").WorkflowWorktreeStatus;
-            groupBy?: "campaign" | "lane" | "flat";
-            lane?: string;
-            campaign?: number;
-            limit?: number;
-        }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListWorktreesResponse>>;
-        listCampaigns: (query?: {
-            topicId?: string;
-            status?: import("./workflowClient").WorkflowWorktreeStatus;
-            limit?: number;
-        } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-        merge(worktreeId: string, input: import("./workflowClient").MergeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        push: (worktreeId: string, input: {
-            targetContext: string;
-            beliefIds?: string[];
-            metadata?: import("./types").JsonObject;
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PushWorktreeResponse>>;
-        openPullRequest: (worktreeId: string, input: {
-            summary: string;
-            reviewers?: string[];
-            status?: "pending_review" | "changes_requested" | "approved" | "blocked";
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").OpenPullRequestResponse>>;
-        pipelineSnapshot(topicId: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
-        complete: (input: {
-            worktreeId: string;
-            keyFindings?: string[];
-            decisionsReached?: string[];
-            nextSteps?: string[];
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        advancePhase(worktreeId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        setPhase(worktreeId: string, phase: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        patchState: (input: {
-            worktreeId: string;
-            patch: import("./gatewayFacades").GatewayRecord;
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        bulkCreate: (input: {
-            worktrees: unknown[];
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-    };
-    context: {
-        listTopics(query?: Parameters<(query?: import("./topicsClient").TopicListInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicListResponse>>>[0]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicListResponse>>;
-        compile: (topicIdOrInput?: string | import("./contextTypes").CompileContextInput, input?: import("./contextTypes").CompileContextInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./contextTypes").PublicCompiledContext>>;
-        recordScopeLearning: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        discover(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        analyzeTopicDensity: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        applyAutoBranching: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        seedBeliefLattice: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        getLatticeCoverage: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
-        matchEntityType(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        discoverEntityConnections(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        triggerBeliefReview(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-    };
-    tasks: {
-        create(input: import("./workflowClient").CreateTaskInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        complete(taskId: string, input: import("./workflowClient").CompleteTaskInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        update(taskId: string, input: import("./workflowClient").UpdateTaskInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        list(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").TaskListResult>>;
-        listByTopic(input: import("./functionSurface").FunctionSurfaceInput & {
-            topicId?: string;
-        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").TaskListResult>>;
-        listByWorktree(input: import("./functionSurface").FunctionSurfaceInput & {
-            worktreeId: string;
-        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").TaskListResult>>;
-        linkChat(taskId: string, input: import("./types").JsonObject, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-    };
-    topics: {
-        list(input?: Parameters<(query?: import("./topicsClient").TopicListInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicListResponse>>>[0]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicListResponse>>;
-        get: (topicId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>;
-        create(input: Parameters<(input: import("./topicsClient").TopicCreateInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        update(topicId: string, input: Parameters<(topicId: string, input: import("./topicsClient").TopicUpdateInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>>[1]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>;
-        tree(topicId: string, query?: Parameters<(topicId: string, query?: import("./topicsClient").TopicTreeQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicTreeResponse>>>[1]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicTreeResponse>>;
-        getTree(input: {
-            rootId: string;
-            maxDepth?: number;
-        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicTreeResponse>>;
-        coverage(topicId: string, query?: Parameters<(topicId: string, query?: import("./topicsClient").TopicCoverageQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>>[1]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>;
-        remove: (topicId: string, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-        bulkCreate: (input: import("./topicsClient").TopicBulkCreateInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-        materializeGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        materializeTopicGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        graphSpine(input?: import("./functionSurface").FunctionSurfaceInput): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        getTopicGraphSpine(input?: import("./functionSurface").FunctionSurfaceInput): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-    };
-    answers: {
-        create(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
-        get(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
-    };
-    contradictions: {
-        flag(args: {
-            beliefA: string;
-            beliefB: string;
-            description: string;
-            topicId?: string;
-            severity?: string;
-            defeatType?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        list(args: {
-            topicId?: string;
-            status?: string;
-            limit?: number;
-            cursor?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").ContradictionsListResult>>;
-        get(contradictionId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        find: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-    };
-    ontologies: {
-        list(input?: {
-            tenantId?: string;
-            tier?: string;
-            status?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<{
-            ontologies: unknown[];
-            total: number;
-            items: unknown[];
-            definitions: unknown[];
-        }>>;
-        get(ontologyId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        bind(input: Parameters<(input: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: Parameters<(input: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        match(input: Parameters<(input: import("./gatewayFacades").OntologyMatchInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: Parameters<(input: import("./gatewayFacades").OntologyMatchInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        create(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        update(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        archive(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        createVersion(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        publishVersion(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        publishOntologyVersion(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        deprecateVersion(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        deprecateOntologyVersion(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        resolveEffective(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        resolveEffectiveOntology(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        raw: {
+            }>;
+            deleteRolePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            checkPermission(query: import("./coreClient").GatewayScope & {
+                topicId?: string;
+                permission?: import("./policyClient").PermissionKind;
+                principal?: string;
+                principalId?: string;
+                beliefClusterId?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./policyClient").PermissionDecision>>;
+            listAccessibleTopics(query?: import("./coreClient").GatewayScope & {
+                permission?: import("./policyClient").PermissionKind;
+                includeShared?: boolean;
+                principal?: string;
+                principalId?: string;
+                limit?: number;
+            }): Promise<{
+                correlationId: string;
+                idempotentReplay: boolean;
+                policyTraceId: string | null;
+                success: true;
+                data: {
+                    permission: import("./policyClient").PermissionKind;
+                    topics: import("./policyClient").PolicyTopicRecord[];
+                    total: number;
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                };
+            }>;
+            filterByPermission(input: import("./coreClient").GatewayScope & {
+                topicIds?: string[];
+                permission?: import("./policyClient").PermissionKind;
+                principal?: string;
+                principalId?: string;
+            }): Promise<{
+                success: true;
+                data: import("./policyClient").FilterByPermissionResponse;
+            }>;
+        };
+        answers: {
+            get(questionId: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+        ontology: {
             list(filters?: import("./coreClient").GatewayScope & {
                 tenantId?: string;
                 tier?: string;
                 status?: string;
             }): Promise<import("./coreClient").PlatformGatewaySuccess<{
+                items: unknown[];
                 ontologies: unknown[];
                 total: number;
+                definitions: unknown[];
+            }>>;
+            get(id: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            bind(input: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            createDefinition(input: import("./ontologyClient").OntologyDefinitionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            updateDefinition(id: string, input: import("./ontologyClient").OntologyDefinitionUpdateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            archiveDefinition(id: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listVersions(ontologyId: string, filters?: import("./coreClient").GatewayScope & {
+                status?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<unknown, "versions">>>;
+            createVersion(ontologyId: string, input: import("./ontologyClient").OntologyVersionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            publishVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            deprecateVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listTopics(ontologyId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "topics">>>;
+        } & {
+            listDefinitions: (filters?: import("./coreClient").GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<{
                 items: unknown[];
+                ontologies: unknown[];
+                total: number;
                 definitions: unknown[];
             }>>;
-            get(id: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            bind(input: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            createDefinition(input: import("./ontologyClient").OntologyDefinitionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            updateDefinition(id: string, input: import("./ontologyClient").OntologyDefinitionUpdateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            archiveDefinition(id: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listVersions(ontologyId: string, filters?: import("./coreClient").GatewayScope & {
+            getDefinition: (id: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listTopicsByOntology: (ontologyId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "topics">>>;
+        };
+        ontologyLinks: {
+            createLink(input: import("./ontologyLinksClient").OntologyLinkWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./ontologyLinksClient").OntologyLinkRecord>>;
+            upsertLink(input: import("./ontologyLinksClient").OntologyLinkWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./ontologyLinksClient").OntologyLinkRecord>>;
+            listLinksForNode(input: import("./ontologyLinksClient").ListOntologyLinksForNodeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./ontologyLinksClient").OntologyLinkRecord, "links">>>;
+            updateLinkStatus(input: import("./ontologyLinksClient").UpdateOntologyLinkStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./ontologyLinksClient").OntologyLinkRecord>>;
+        };
+        orgGraphSearch: {
+            search(input: import("./orgGraphSearchClient").OrgGraphSearchInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
+            getNode(input: import("./orgGraphSearchClient").GetOrgGraphNodeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResult>>;
+            listByProvenance(input: import("./orgGraphSearchClient").ListOrgGraphByProvenanceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
+            listPublishedFromWorkspace(input: import("./orgGraphSearchClient").ListPublishedFromWorkspaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./orgGraphSearchClient").OrgGraphSearchResponse>>;
+        };
+        functionSurface: {
+            sessionId: string;
+            activateWorktree(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            addEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            addWorktree(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            analyzeGraphImpact(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            analyzeTopicDensity(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            answerQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            appendSlScoring(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            applyAutoBranching(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            applyLensToTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            applyOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            archiveBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            archiveEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            archiveEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            archiveOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            archiveQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            batchCreateEdges(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            batchCreateEpistemicNodes(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            beginBuildSession(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            bisectConfidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            broadcastMessage(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            checkPermission(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            claimFiles(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            compileCapabilitySlice(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            compileContext(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            completeTask(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createAnswer(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createEdge(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createEpistemicContract(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createLens(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createOntologyVersion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createTask(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            deprecateOntologyVersion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            detectConfirmationBias(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            detectGraphDrift(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            discover(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            discoverEntityConnections(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            endSession(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            evaluateContract(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            expandGraphNeighborhood(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            expandNarrative(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            filterByPermission(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            findContradictions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            findMissingQuestions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            findRelatedNodes(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            flagContradiction(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            forkBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            generateSessionHandoff(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getAgentInbox(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getAnswer(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getAuditTrail(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getCampaignContext(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getChangeHistory(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getCodeContext(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getConfidenceHistory(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getContractStatus(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getByNodeIds(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getFailureLog(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getFalsificationQuestions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getGraphGaps(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getGraphNeighborhood(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getGraphStructureAnalysis(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getHighPriorityQuestions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getLatticeCoverage(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getLoadBearingNodes(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getObservationContext(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getOperatorGauntlet(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getReasoningExemplars(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getTopicCoverage(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getTopicGraphSpine(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getTopicTree(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getWorktree(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            heartbeatSession(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            hybridDiscover(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            whoami(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            ingestObservation(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            linkEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            linkEvidenceToBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            linkEvidenceToQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listActiveSessions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listAllWorktrees(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listBeliefs(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listCampaigns(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listEpistemicNodes(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listGraphIntelligenceQueries(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listLenses(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listMissingForTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listOntologies(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listQuestions(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listTasks(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listTopics(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listWorktrees(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listWorktreesByBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            lucernOrient(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            manageWritePolicy(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            matchEntityType(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            materializeTopicGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            merge(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            openPullRequest(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            pipelineSnapshot(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            publishOntologyVersion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            push(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            queryAnchorHistory(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            queryLineage(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            markEmbeddingBackfillQueued(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            recordAttempt(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            recordJudgment(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            recordScopeLearning(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            refineBelief(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            refineQuestion(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            registerSession(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            removeEdge(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            removeEdgesBetween(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            removeLensFromTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            resolveEffectiveOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            resolveInteractivePrincipal(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            resolveTopicSemantic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            runGraphIntelligenceQuery(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            searchBeliefs(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            vectorSearchByTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            searchEvidence(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            seedBeliefLattice(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            sendAgentMessage(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            supersedeEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            traceEntityImpact(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            traverseGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            triggerBeliefReview(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateEdge(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateOntology(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateQuestionStatus(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateTask(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateTopic(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateWorktreeMetadata(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateWorktreeTargets(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            verifyEpistemicNode(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+        };
+        controlPlane: {
+            identity: {
+                resolveInteractivePrincipal(input: import("./control-plane").ResolveInteractivePrincipalInput): Promise<import("./control-plane").ResolveInteractivePrincipalResponse>;
+            };
+        };
+        toolRegistry: {
+            listCatalog(input: import("./toolRegistryClient").ToolRegistryQuery): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
+            listExecutable(input: import("./toolRegistryClient").ToolRegistryQuery): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
+            listEffectiveTools(input: import("./toolRegistryClient").EffectiveToolsQuery): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
+            upsertCoreTools(input: import("./toolRegistryClient").UpsertCoreToolsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
+            setPackToolsStatus(input: import("./toolRegistryClient").SetPackToolsStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./toolRegistryClient").ToolCatalogEntry, "tools">>>;
+            createAcl(input: import("./toolRegistryClient").CreateToolAclInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./toolRegistryClient").ToolAclRecord>>;
+            deleteAcl(input: import("./toolRegistryClient").DeleteToolAclInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+                aclId: string;
+                deleted: boolean;
+            }>>;
+            registerCustomTool(input: import("./toolRegistryClient").RegisterCustomToolInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./toolRegistryClient").ToolCatalogEntry>>;
+        };
+        modelRuntime: {
+            listModels(input: import("./modelRuntimeClient").ModelRuntimeScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./modelRuntimeClient").ModelRegistryRecord, "models">>>;
+            getModel(input: import("./modelRuntimeClient").ModelRuntimeScope & {
+                modelId: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelRegistryRecord>>;
+            listFunctionSlots(input: import("./modelRuntimeClient").ModelRuntimeScope & {
+                functionName?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./modelRuntimeClient").ModelFunctionSlot, "slots">>>;
+            resolveSlot(input: import("./modelRuntimeClient").ResolveModelSlotInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelFunctionSlot>>;
+            updateSlotConfig(input: import("./modelRuntimeClient").UpdateModelSlotConfigInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./modelRuntimeClient").ModelFunctionSlot>>;
+        };
+        packs: {
+            listCatalog(): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
+            getDiscoveryCatalog(): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            getDiscoveryDetail(packKey: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listStates(query?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
+            getHealth(packKey: string, query?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listTelemetry(query?: import("./coreClient").GatewayScope & {
+                lookbackHours?: number;
+                limit?: number;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "telemetry">>>;
+            createEntitlement(input: import("./packsClient").PackEntitlementInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            install(input: import("./packsClient").PackInstallInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            enable(input: import("./packsClient").PackEnableInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            disable(input: import("./packsClient").PackDisableInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            uninstall(input: import("./packsClient").PackUninstallInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            upgrade(input: import("./packsClient").PackUpgradeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        } & {
+            getCatalog: () => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
+            getStates: (query?: import("./coreClient").GatewayScope) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
+            getTelemetry: (query?: import("./coreClient").GatewayScope & {
+                lookbackHours?: number;
+                limit?: number;
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "telemetry">>>;
+            updateEntitlement: (input: import("./packsClient").PackEntitlementInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            upsertEntitlement: (input: import("./packsClient").PackEntitlementInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        };
+        reports: {
+            listTemplates: (args?: {
+                slug?: string;
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ReportTemplatesResponse>>;
+            getTemplates: (args?: {
+                slug?: string;
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ReportTemplatesResponse>>;
+            listReports: (input: import("./types").TopicIdentifierInput, args?: {
+                summary?: boolean;
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "reports">>>;
+            getReport: (reportId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ReportWithSectionsResponse>>;
+        };
+        learning: {
+            listRecentExecutions: (args?: {
+                namespace?: string;
+                topicId?: string;
+                audienceMode?: string;
+                success?: boolean;
+                limit?: number;
+            } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "executions">>>;
+            getRecentExecutions: (args?: {
+                namespace?: string;
+                topicId?: string;
+                audienceMode?: string;
+                success?: boolean;
+                limit?: number;
+            } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "executions">>>;
+            getExecutionStats: (args?: {
+                namespace?: string;
+                topicId?: string;
+                audienceMode?: string;
+                hours?: number;
+            } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        };
+        mcp: {
+            bootstrapSession(input?: import("./mcpClient").McpBootstrapSessionInput): Promise<import("./mcpClient").McpBootstrapSessionResponse>;
+            checkWritePolicy(input: import("./mcpClient").McpCheckWritePolicyInput): Promise<import("./mcpClient").McpCheckWritePolicyResponse>;
+            beginBuildSession(input: import("./mcpClient").McpBeginBuildSessionInput): Promise<import("./mcpClient").McpBeginBuildSessionResponse>;
+            evaluateEngineeringContract(input: import("./mcpClient").McpEvaluateEngineeringContractInput): Promise<import("./mcpClient").McpContractEvaluationResponse>;
+            evaluateResearchContract(input: import("./mcpClient").McpEvaluateResearchContractInput): Promise<import("./mcpClient").McpContractEvaluationResponse>;
+        };
+        jobs: {
+            enqueue(input: import("./jobsClient").EnqueueJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
+            list(input: import("./jobsClient").JobsScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./jobsClient").JobRecord, "jobs">>>;
+            claim(input: import("./jobsClient").ClaimJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
+            updateStatus(input: import("./jobsClient").UpdateJobStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
+            retry(input: import("./jobsClient").RetryJobInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRecord>>;
+            recordRunStart(input: import("./jobsClient").RecordJobRunStartInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRunRecord>>;
+            recordRunFinish(input: import("./jobsClient").RecordJobRunFinishInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./jobsClient").JobRunRecord>>;
+        };
+        telemetry: {
+            logSystemEvent(input: import("./telemetry-client").LogSystemEventInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+                eventId?: string;
+                recorded: boolean;
+            }>>;
+            logToolCallsBatch(input: import("./telemetry-client").LogToolCallsBatchInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+                recorded: number;
+            }>>;
+            recordEpistemicAudit(input: import("./telemetry-client").RecordEpistemicAuditInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+                auditId?: string;
+                recorded: boolean;
+            }>>;
+            recordPolicyDecision(input: import("./telemetry-client").RecordTelemetryPolicyDecisionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<{
+                decisionId?: string;
+                recorded: boolean;
+            }>>;
+            startRun(input: import("./telemetry-client").StartTelemetryRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./telemetry-client").TelemetryRunRecord>>;
+            finishRun(input: import("./telemetry-client").FinishTelemetryRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./telemetry-client").TelemetryRunRecord>>;
+            listRuns(input: import("./telemetry-client").TelemetryScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./telemetry-client").TelemetryRunRecord, "runs">>>;
+        };
+        harness: {
+            listAgentDefinitions(scope?: import("./coreClient").GatewayScope & {
                 status?: string;
-            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<unknown, "versions">>>;
-            createVersion(ontologyId: string, input: import("./ontologyClient").OntologyVersionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            publishVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            deprecateVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listTopics(ontologyId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "topics">>>;
+                limit?: number;
+                cursor?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "agents">>>;
+            getAgentDefinition(agentId: string, scope?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            createAgentDefinition(input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            updateAgentDefinition(agentId: string, input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            invokeManagedAgentDefinition(agentId: string, input: Omit<import("./harnessClient").HarnessInvokeManagedAgentInput, "agentDefinitionId">, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listAgentRuns(agentId: string, scope?: import("./coreClient").GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
+            listToolDefinitions(scope?: import("./coreClient").GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+                gateClassification?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "tools">>>;
+            getToolDefinition(toolId: string, scope?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            createToolDefinition(input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            updateToolDefinition(toolId: string, input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            executeToolDefinition(toolId: string, input?: import("./harnessClient").HarnessExecuteToolInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./harnessClient").HarnessExecuteToolResult>>;
+            listRunEntries(scope?: import("./coreClient").GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
+            startHarnessRun(input: import("./harnessClient").HarnessStartRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            getRunLedgerEntry(runId: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            reportHarnessRunEvent(runId: string, input: import("./harnessClient").HarnessRunReportInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            heartbeatHarnessRun(runId: string, input: {
+                reportingToken: string;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            completeHarnessRun(runId: string, input: import("./harnessClient").HarnessCompleteRunInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listPromptResolutions(query?: {
+                runId?: string;
+                promptName?: string;
+                limit?: number;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "prompts">>>;
+            getScopeTaxonomy(): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
         } & {
-            listDefinitions: (filters?: import("./coreClient").GatewayScope & {
-                tenantId?: string;
-                tier?: string;
+            registerAgentDefinition: (input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listRunsForAgent: (agentId: string, scope?: import("./coreClient").GatewayScope & {
                 status?: string;
-            }) => Promise<import("./coreClient").PlatformGatewaySuccess<{
-                ontologies: unknown[];
-                total: number;
-                items: unknown[];
-                definitions: unknown[];
-            }>>;
-            getDefinition: (id: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-            listTopicsByOntology: (ontologyId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "topics">>>;
+                limit?: number;
+                cursor?: string;
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
+            registerToolDefinition: (input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listRunLedgerEntries: (scope?: import("./coreClient").GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
+        };
+        schema: {
+            listPacks(scope?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "packs">>>;
+            installPack(input: import("./schema-client").SchemaPackInstallInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            getPack(packId: string, scope?: import("./coreClient").GatewayScope): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listEntitlements(scope?: import("./coreClient").GatewayScope & {
+                packKey?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "entitlements">>>;
+            createEntitlement: (input: import("./schema-client").SchemaEntitlementInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            updateEntitlement: (input: import("./schema-client").SchemaEntitlementInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            upsertEntitlement: (input: import("./schema-client").SchemaEntitlementInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        };
+        audiences: {
+            listRegistry: (query?: import("./coreClient").GatewayScope & {
+                effective?: boolean;
+                status?: "active" | "disabled" | "archived";
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "registryEntries">>>;
+            getRegistry: (query?: import("./coreClient").GatewayScope & {
+                effective?: boolean;
+                status?: "active" | "disabled" | "archived";
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "registryEntries">>>;
+            createRegistryEntry: (input: import("./audiences-client").AudienceRegistryInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            updateRegistryEntry: (input: import("./audiences-client").AudienceRegistryInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            upsertRegistry: (input: import("./audiences-client").AudienceRegistryInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listGrants: (query?: import("./coreClient").GatewayScope & {
+                audienceKey?: string;
+                principalId?: string;
+                groupId?: string;
+                status?: "active" | "revoked" | "expired";
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "grants">>>;
+            getGrants: (query?: import("./coreClient").GatewayScope & {
+                audienceKey?: string;
+                principalId?: string;
+                groupId?: string;
+                status?: "active" | "revoked" | "expired";
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "grants">>>;
+            createGrant: (input: import("./audiences-client").AudienceGrantInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            grant: (input: import("./audiences-client").AudienceGrantInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            deleteGrant: (input: import("./audiences-client").AudienceGrantRevokeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            revokeGrant: (input: import("./audiences-client").AudienceGrantRevokeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        };
+        topics: {
+            list(query?: import("./topicsClient").TopicListInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicListResponse>>;
+            get(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>;
+            create(input: import("./topicsClient").TopicCreateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>;
+            update(topicId: string, input: import("./topicsClient").TopicUpdateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>;
+            getTree(topicId: string, query?: import("./topicsClient").TopicTreeQuery): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicTreeResponse>>;
+            getCoverage(topicId: string, query?: import("./topicsClient").TopicCoverageQuery): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>;
+            remove(topicId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            bulkCreate(input: import("./topicsClient").TopicBulkCreateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
         };
     };
-    graph: {
-        nodes: import("./client-assembly-types").ClientNodesNamespace;
-        createEdge: (input: import("./graphClient").CreateEdgeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformGraphEdge>>;
-        neighborhood(args: Parameters<(query: import("./graphClient").NeighborhoodInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<import("./types").GraphNeighborhoodResponse>>;
-        queryLineage: (args_0: string, args_1?: number | undefined) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        getConfidenceHistory: (args_0: string) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        getOpinionHistory: (args_0: string) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        getAuditTrail: (nodeId: string, limit?: number) => Promise<{
-            entries: import("./client-assembly-types").AuditTrailEntry[];
-        }>;
-        traverse(args: {
-            startNode: string;
-            direction?: string;
-            maxDepth?: number;
-            topicId?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-        analyze(args: {
-            topicId?: string;
-            limit?: number;
-            metric?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-        bias(args: {
-            topicId?: string;
-            threshold?: number;
-            limit?: number;
-        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-        gaps(args: {
-            topicId?: string;
-            minConfidence?: number;
-        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-        falsify(args: {
-            topicId?: string;
-            beliefId?: string;
-            beliefIds?: string[];
-            minConfidence?: number;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        traceEntityImpact(args: {
-            nodeId: string;
-            topicId?: string;
-        }): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        searchBeliefs: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        findContradictions: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        bisectConfidence: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        listBeliefs: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        detectConfirmationBias(topicId: string, threshold?: number): Promise<{
-            topicId: string;
-            threshold: number;
-        }>;
-        getStructureAnalysis(topicId: string): Promise<{
-            topicId: string;
-        }>;
-        getFalsificationQuestions(topicId: string, beliefIds?: string[]): Promise<{
-            topicId: string;
-            questions: unknown;
-        }>;
-    };
-    themes: {
-        listByTopic(input: {
+    judgments: {
+        create: (input: import("./decisionsClient").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
+        record: (input: import("./decisionsClient").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
+        list: (query: import("./decisionsClient").ListJudgmentsInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListJudgmentsResponse>>;
+        get: (judgmentId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GetJudgmentResponse>>;
+        recordOutcome: (judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
+        updateOutcome: (judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
+        readiness(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentReadinessResponse>>;
+        calibration(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentCalibrationResponse>>;
+        pendingOutcomeReview(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PendingJudgmentOutcomeRecord, "reviews">>>;
+        transitionAuditIntegrity(args: {
             topicId?: string;
-            projectId?: string;
-            query?: string;
-            limit?: number;
-            cursor?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+            judgmentId?: string;
+            includePassing?: boolean;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentTransitionAuditIntegrityResponse>>;
     };
-    graphSearch: {
-        keywordSearchNodes(input: {
-            topicId?: string;
-            projectId?: string;
-            query?: string;
-            sourceText?: string;
-            nodeType?: string;
-            nodeTypes?: string[];
-            limit?: number;
-            cursor?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+    decisions: {
+        create: (input: import("./decisionsClient").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
+        record: (input: import("./decisionsClient").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
+        list: (query: import("./decisionsClient").ListJudgmentsInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListJudgmentsResponse>>;
+        get: (judgmentId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").GetJudgmentResponse>>;
+        recordOutcome: (judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
+        lessons(decisionId: string, input: import("./types").JsonObject, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        archive(decisionId: string, input?: import("./types").JsonObject, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        readiness(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentReadinessResponse>>;
+        calibration(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentCalibrationResponse>>;
+        pendingOutcomeReview(topicId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PendingJudgmentOutcomeRecord, "reviews">>>;
     };
-    classifiers: {
-        listBeliefCandidates(input: {
+    worktrees: {
+        createBranch: (input: {
+            name: string;
             topicId?: string;
-            projectId?: string;
-            classifierKey?: string;
-            query?: string;
-            limit?: number;
-            cursor?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-    };
-    archetypes: {
-        getJudgmentSignature(input: {
+            description?: string;
+            metadata?: import("./types").JsonObject;
+        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowBranchRecord>>;
+        createLens: (input: {
+            name: string;
+            workspaceId?: string;
             topicId?: string;
-            projectId?: string;
-            principalId?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-    };
-    events: {
-        list(query?: Parameters<(query?: import("./gatewayFacades").EventsListQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").EventsListResult>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").EventsListResult>>;
-        replay(input: Parameters<(input: import("./gatewayFacades").ReplayEventsInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        recordEvent: (input: import("./eventingClient").RecordEventInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingRecord>>;
-        listEvents: (input: import("./eventingClient").EventingScope) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./eventingClient").EventingRecord, "events">>>;
-        listWebhooks: (input: import("./eventingClient").EventingScope) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./eventingClient").EventingWebhookRecord, "webhooks">>>;
-        enqueueDelivery: (input: import("./eventingClient").EnqueueDeliveryInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
-        recordDeliveryAttempt: (input: import("./eventingClient").RecordDeliveryAttemptInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
-        updateDeliveryStatus: (input: import("./eventingClient").UpdateDeliveryStatusInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./eventingClient").EventingDeliveryRecord>>;
-    };
-    beliefs: {
-        create(input: import("./beliefsClient").CreateBeliefInput): Promise<import("./client-config").GatewayDataEnvelope<import("./types").PlatformBeliefRecord>>;
-        get(nodeId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").BeliefRecord>>;
-        refine(nodeId: string, textOrInput: string | {
-            text: string;
-            rationale?: string;
-        }, rationale?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").BeliefRecord>>;
-        updateRationale(input: Parameters<(input: {
-            id?: string;
-            nodeId?: string;
-            beliefId?: string;
-            rationale?: string;
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        linkBeliefs(input: Parameters<(input: {
-            fromNodeId: string;
-            toNodeId: string;
-            edgeType: string;
-            weight?: number;
-            context?: string;
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        unlinkEvidence(input: Parameters<(input: {
-            beliefNodeId?: string;
-            beliefId?: string;
-            insightId?: string;
-            evidenceId?: string;
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        updateCriticality(input: Parameters<(input: {
-            id?: string;
-            nodeId?: string;
-            beliefId?: string;
-            criticality: string;
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        batchUpdateCriticality(input: Parameters<(input: {
-            updates: import("./gatewayFacades").GatewayRecord[];
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        reassignTopic(input: Parameters<(input: {
-            beliefNodeIds?: string[];
-            beliefIds?: string[];
-            targetTopicId: string;
-            reason?: string;
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        fork(nodeId: string, input: import("./client-config").BeliefsCompatForkInput): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").BeliefRecord>>;
-        archive(nodeId: string, input?: string | {
-            reason?: string;
-            rationale?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        list(args: {
+            description?: string;
+            perspectiveType: import("./workflowClient").WorkflowLensPerspectiveType;
+            promptTemplates?: import(".").LensPromptTemplateReference[];
+            workflowTemplates?: import(".").LensWorkflowTemplate[];
+            taskTemplates?: import(".").LensTaskTemplate[];
+            questionTemplates?: import(".").LensQuestionTemplate[];
+            filterCriteria?: import("./types").JsonObject;
+        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowLensRecord>>;
+        listLenses: (query: {
+            workspaceId?: string;
             topicId?: string;
-            worktreeId?: string;
-            status?: string;
-            minConfidence?: number;
-            limit?: number;
-            cursor?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").BeliefsListResult>>;
-        search: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        lineage(nodeId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").BeliefsLineageResult>>;
-        confidenceHistory(nodeId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        opinionHistory: (args_0: string) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        createContract(nodeId: string, input: Parameters<(id: string, input: import("./gatewayFacades").BeliefContractInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        bisect(nodeId: string, input: Parameters<(id: string, input: import("./gatewayFacades").BeliefBisectInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-    };
-    webhooks: {
-        create(input: Parameters<(input: import("./gatewayFacades").WebhookCreateInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        list(query?: Parameters<(query?: import("./gatewayFacades").WebhookListQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").WebhooksListResult>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").WebhooksListResult>>;
-        get(id: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        update(id: string, input: Parameters<(id: string, input: import("./gatewayFacades").WebhookUpdateInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        delete(id: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        test(id: string, input?: Parameters<(id: string, input?: import("./gatewayFacades").WebhookTestInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        deliveries(id: string, query?: Parameters<(id: string, query?: import("./gatewayFacades").WebhookDeliveriesQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        health(id: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-    };
-    edges: {
-        create(args: import("./functionSurface").FunctionSurfaceInput & {
-            from?: unknown;
-            to?: unknown;
-            sourceId?: string;
-            targetId?: string;
-            edgeType: string;
+            status?: import("./workflowClient").WorkflowLensStatus;
+            perspectiveType?: import("./workflowClient").WorkflowLensPerspectiveType;
+        } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowLensRecord, "lenses">>>;
+        applyLensToTopic: (input: {
+            lensId: string;
             topicId?: string;
-            confidence?: number;
-            weight?: number;
-            context?: string;
-            reasoning?: string;
-        }, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        createEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        update(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        updateEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        remove(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        removeEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        removeBetween(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        removeEdgesBetween(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        batchCreate(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        batchCreateEdges(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
-        delete(input: Parameters<(input: {
-            edgeIds: string[];
-        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        list(args: {
-            sourceId: string;
-            edgeType?: string;
+            metadata?: import("./types").JsonObject;
+        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>;
+        removeLensFromTopic: (input: {
+            lensId: string;
+            topicId?: string;
+        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>;
+        create(input: import("./workflowClient").AddWorktreeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        add(input: import("./workflowClient").AddWorktreeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        list(query: Parameters<(query: {
+            topicId?: string;
+            branchId?: string;
+            status?: import("./workflowClient").WorkflowWorktreeStatus;
+            groupBy?: "campaign" | "lane" | "flat";
+            lane?: string;
+            campaign?: number;
             limit?: number;
-            cursor?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayList>>;
-        traverse(args: {
-            startNode: string;
-            direction?: string;
-            maxDepth?: number;
+        } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowWorktreeRecord, "worktrees">>>>[0]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").WorktreesListResult>>;
+        listByTopic(query: Parameters<(query: {
             topicId?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-    };
-    evidence: {
-        create(args: import("./client-evidence-compat").EvidenceCompatInput): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
-        add: (args_0: import("./client-evidence-compat").EvidenceCompatInput) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-        get(evidenceId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        list(args: {
+            branchId?: string;
+            status?: import("./workflowClient").WorkflowWorktreeStatus;
+            groupBy?: "campaign" | "lane" | "flat";
+            lane?: string;
+            campaign?: number;
+            limit?: number;
+        } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowWorktreeRecord, "worktrees">>>>[0]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").WorktreesListResult>>;
+        findByPairedSprint(input: {
+            sprintId: string;
             topicId?: string;
-            targetId?: string;
             limit?: number;
-            cursor?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayList>>;
-        search(args: {
-            q?: string;
-            query?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        activate(worktreeId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        updateMetadata(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        update(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        updateTargets(input: Parameters<(input: import("./workflowClient").UpdateWorktreeTargetsInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>>[0]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        listAll: (query?: {
+            status?: import("./workflowClient").WorkflowWorktreeStatus;
+            groupBy?: "campaign" | "lane" | "flat";
+            lane?: string;
+            campaign?: number;
+            limit?: number;
+        }) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListWorktreesResponse>>;
+        listCampaigns: (query?: {
             topicId?: string;
-            targetId?: string;
-            methodology?: string;
+            status?: import("./workflowClient").WorkflowWorktreeStatus;
             limit?: number;
-            cursor?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayList>>;
-        link(args: {
-            evidenceId: string;
-            targetId?: string;
-            beliefId?: string;
-            questionId?: string;
-            targetType?: "belief" | "question" | string;
-            weight?: number;
-            evidenceRelation?: "supports" | "contradicts";
-            confidence?: number;
-            rationale?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").EvidenceLinkResult>>;
-        linkToBelief(args: {
-            evidenceId: string;
-            beliefId: string;
-            weight?: number;
-            evidenceRelation?: "supports" | "contradicts";
-            confidence?: number;
-            rationale?: string;
-        }): Promise<{
-            beliefId: string;
-        }>;
-        classifyEvidence(beliefId: string, evidenceId: string, config?: Parameters<(beliefId: string, evidenceId: string, classificationConfig?: import("./evidenceClient").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./evidenceClient").ClassifyEvidenceResult>>>[2], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./evidenceClient").ClassifyEvidenceResult>>;
-        classifyEvidenceBatch(beliefId: string, evidence: Parameters<(beliefId: string, evidence: import("./evidenceClient").ClassifyEvidenceBatchItem[], classificationConfig?: import("./evidenceClient").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./evidenceClient").ClassifyEvidenceBatchResult>>>[1], config?: Parameters<(beliefId: string, evidence: import("./evidenceClient").ClassifyEvidenceBatchItem[], classificationConfig?: import("./evidenceClient").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./evidenceClient").ClassifyEvidenceBatchResult>>>[2], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./evidenceClient").ClassifyEvidenceBatchResult>>;
-        updateStatus(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        update(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        flagIncorrect(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        remove(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        updateVerificationStatus(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        } & import("./types").TopicIdentifierInput) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+        merge(worktreeId: string, input: import("./workflowClient").MergeInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        push: (worktreeId: string, input: {
+            targetContext: string;
+            beliefIds?: string[];
+            metadata?: import("./types").JsonObject;
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PushWorktreeResponse>>;
+        openPullRequest: (worktreeId: string, input: {
+            summary: string;
+            reviewers?: string[];
+            status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").OpenPullRequestResponse>>;
+        pipelineSnapshot(topicId: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+        complete: (input: {
+            worktreeId: string;
+            keyFindings?: string[];
+            decisionsReached?: string[];
+            nextSteps?: string[];
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        advancePhase(worktreeId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        setPhase(worktreeId: string, phase: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        patchState: (input: {
+            worktreeId: string;
+            patch: import("./gatewayFacades").GatewayRecord;
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        bulkCreate: (input: {
+            worktrees: unknown[];
+        }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
     };
-    sources: {
-        upsert(input: Parameters<(spec: import("./sources-client").UpsertSourceSpec, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformSourceRecord>>>[0], idempotencyKey?: Parameters<(spec: import("./sources-client").UpsertSourceSpec, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformSourceRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./types").PlatformSourceRecord>>;
-        get(sourceId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./types").PlatformSourceRecord>>;
+    context: {
+        listTopics(query?: Parameters<(query?: import("./topicsClient").TopicListInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicListResponse>>>[0]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicListResponse>>;
+        compile: (topicIdOrInput?: string | import("./contextTypes").CompileContextInput, input?: import("./contextTypes").CompileContextInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./contextTypes").PublicCompiledContext>>;
+        recordScopeLearning: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        discover(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        analyzeTopicDensity: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        applyAutoBranching: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        seedBeliefLattice: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getLatticeCoverage: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        matchEntityType(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        discoverEntityConnections(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        triggerBeliefReview(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
     };
-    questions: {
-        create(args: {
-            text: string;
+    tasks: {
+        create(input: import("./workflowClient").CreateTaskInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        complete(taskId: string, input: import("./workflowClient").CompleteTaskInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        update(taskId: string, input: import("./workflowClient").UpdateTaskInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        list(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").TaskListResult>>;
+        listByTopic(input: import("./functionSurface").FunctionSurfaceInput & {
             topicId?: string;
-            priority?: string;
-            linkedBeliefId?: string;
-            metadata?: import("./types").JsonObject;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").TaskListResult>>;
+        listByWorktree(input: import("./functionSurface").FunctionSurfaceInput & {
+            worktreeId: string;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").TaskListResult>>;
+        linkChat(taskId: string, input: import("./types").JsonObject, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    topics: {
+        list(input?: Parameters<(query?: import("./topicsClient").TopicListInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicListResponse>>>[0]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicListResponse>>;
+        get: (topicId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>;
+        create(input: Parameters<(input: import("./topicsClient").TopicCreateInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>>[0]): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        update(topicId: string, input: Parameters<(topicId: string, input: import("./topicsClient").TopicUpdateInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>>[1]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicRecord>>;
+        tree(topicId: string, query?: Parameters<(topicId: string, query?: import("./topicsClient").TopicTreeQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicTreeResponse>>>[1]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicTreeResponse>>;
+        getTree(input: {
+            rootId: string;
+            maxDepth?: number;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicTreeResponse>>;
+        coverage(topicId: string, query?: Parameters<(topicId: string, query?: import("./topicsClient").TopicCoverageQuery) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>>[1]): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>;
+        remove: (topicId: string, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+        bulkCreate: (input: import("./topicsClient").TopicBulkCreateInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+        materializeGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        materializeTopicGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        graphSpine(input?: import("./functionSurface").FunctionSurfaceInput): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        getTopicGraphSpine(input?: import("./functionSurface").FunctionSurfaceInput): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+    };
+    answers: {
+        create(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>;
+        get(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    };
+    contradictions: {
+        flag(args: {
+            beliefA: string;
+            beliefB: string;
+            description: string;
+            topicId?: string;
+            severity?: string;
+            defeatType?: string;
         }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        get(questionId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        refine(questionId: string, input: string | {
-            text?: string;
-            question?: string;
-            rationale?: string;
-            linkedWorktreeId?: string;
-        }, refinementReason?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
         list(args: {
             topicId?: string;
             status?: string;
-            priority?: string;
-            worktreeId?: string;
             limit?: number;
             cursor?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").QuestionsListResult>>;
-        updateStatus(questionId: string, status: string, rationale?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        batchCreate(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        add(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        updatePriority(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        advanceToConviction(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        updateConviction(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        finalizeConviction(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        update(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        delete(input: Parameters<(input: import("./gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        answer(questionId: string, input: {
-            text: string;
-            confidence?: string;
-            evidenceIds?: string[];
-            rationale?: string;
-        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        archive(questionId: string, reason?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
-        linkEvidence(args: {
-            evidenceId: string;
-            questionId: string;
-            relevance?: number;
-            weight?: number;
-            rationale?: string;
-        }): Promise<{
-            questionId: string;
-            relevance: number | undefined;
-        }>;
-        getHighPriority(args: {
-            topicId?: string;
-            limit?: number;
-            includeAnswered?: boolean;
-        }): Promise<{
-            questions: ({
-                priority?: string;
-            } & Record<string, unknown>)[];
-        }>;
-        findMissing(args: {
-            topicId?: string;
-            minConfidence?: number;
-        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").ContradictionsListResult>>;
+        get(contradictionId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        find: (args_0: import("./types").JsonObject) => Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+    };
+    ontologies: {
+        list(input?: {
+            tenantId?: string;
+            tier?: string;
+            status?: string;
+        }): Promise<import("./client-config").GatewayDataEnvelope<{
+            items: unknown[];
+            ontologies: unknown[];
+            total: number;
+            definitions: unknown[];
+        }>>;
+        get(ontologyId: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        bind(input: Parameters<(input: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: Parameters<(input: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        match(input: Parameters<(input: import("./gatewayFacades").OntologyMatchInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: Parameters<(input: import("./gatewayFacades").OntologyMatchInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").GatewayRecord>>>[1]): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+        create(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        update(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        archive(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        createVersion(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        publishVersion(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        publishOntologyVersion(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        deprecateVersion(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        deprecateOntologyVersion(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        resolveEffective(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        resolveEffectiveOntology(input: import("./functionSurface").FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        raw: {
+            list(filters?: import("./coreClient").GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<{
+                items: unknown[];
+                ontologies: unknown[];
+                total: number;
+                definitions: unknown[];
+            }>>;
+            get(id: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            bind(input: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            createDefinition(input: import("./ontologyClient").OntologyDefinitionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            updateDefinition(id: string, input: import("./ontologyClient").OntologyDefinitionUpdateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            archiveDefinition(id: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listVersions(ontologyId: string, filters?: import("./coreClient").GatewayScope & {
+                status?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<unknown, "versions">>>;
+            createVersion(ontologyId: string, input: import("./ontologyClient").OntologyVersionInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            publishVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            deprecateVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listTopics(ontologyId: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "topics">>>;
+        } & {
+            listDefinitions: (filters?: import("./coreClient").GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }) => Promise<import("./coreClient").PlatformGatewaySuccess<{
+                items: unknown[];
+                ontologies: unknown[];
+                total: number;
+                definitions: unknown[];
+            }>>;
+            getDefinition: (id: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listTopicsByOntology: (ontologyId: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "topics">>>;
+        };
     };
     config: LucernClientConfig;
     version: string;