@lucern/sdk 1.0.28 → 1.0.30

package/dist/client.d.ts

@@ -1,5 +1,6 @@
-import type { LucernClientConfig } from "./clientConfig";
-export type { LucernClientConfig } from "./clientConfig";
+import type { CustomToolNamespace, LucernClientConfig } from "./client-config";
+import { clearRegisteredCustomTools, listRegisteredCustomTools, registerCustomTool, unregisterCustomTool } from "./customTools";
+export type { LucernClientConfig } from "./client-config";
 /**
  * Create the high-level Lucern SDK client with all domain namespaces.
  *
@@ -8,295 +9,1758 @@ export type { LucernClientConfig } from "./clientConfig";
  */
 export declare function createLucernClient(config?: LucernClientConfig): {
     coordination: {
-        registerSession: any;
-        heartbeatSession: any;
-        endSession: any;
-        listActiveSessions: any;
-        sendAgentMessage: any;
-        broadcastMessage: any;
-        getInbox: any;
-        getAgentInbox: any;
-        claimFiles: any;
+        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): any;
-        listAccessibleTopics(input?: Parameters<(...args: any[]) => any>[0]): any;
-        filterByPermission(input: import("./functionSurface").FunctionSurfaceInput): any;
-        compileCapabilitySlice(input: Parameters<any>[0], idempotencyKey?: string): any;
-        manageWritePolicy(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        raw: Record<string, (...args: any[]) => any> & {
-            create: (...args: any[]) => any;
-            link: (...args: any[]) => any;
+        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<{
+            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;
+        }>;
+        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: {
+            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: any;
-        ingestObservation: any;
-        getContext: any;
-        getObservationContext: any;
+        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: any;
-        getChangeHistory: any;
-        recordAttempt: any;
-        getFailureLog: any;
+        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): any;
-        createEpistemicContract(input: import("./functionSurface").FunctionSurfaceInput): any;
+        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;
-        }): any;
-        evaluate(input: import("./functionSurface").FunctionSurfaceInput): any;
-        evaluateContract(input: import("./functionSurface").FunctionSurfaceInput): any;
-        getStatus(input: import("./functionSurface").FunctionSurfaceInput): any;
-        getContractStatus(input: import("./functionSurface").FunctionSurfaceInput): any;
+        }): 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: any;
+        generateSessionHandoff: (input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
     };
     hybrid: {
-        discover: any;
-        hybridDiscover: any;
-        resolveTopicSemantic: any;
-        expandGraphNeighborhood: any;
-        findRelatedNodes: any;
-        analyzeGraphImpact: any;
-        detectGraphDrift: any;
-    };
-    embeddings: any;
-    graphAnalysis: any;
-    graphRecommendations: any;
-    orgGraphSearch: any;
-    ontologyLinks: Record<string, (...args: any[]) => any>;
-    graphStateClassifier: any;
-    modelRuntime: any;
-    jobs: any;
-    telemetry: any;
-    publication: Record<string, (...args: any[]) => any>;
-    contentPublication: Record<string, (...args: any[]) => any>;
+        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: any;
-        listExecutable: any;
-        listEffectiveTools: any;
-        upsertCoreTools: any;
-        setPackToolsStatus: any;
-        createAcl: any;
-        deleteAcl: any;
-        registerCustomTool: any;
-        register: any;
-        unregister: any;
-        list: any;
-        clear: any;
-        invoke(name: string, input?: import("./clientConfig").CustomToolInput): any;
-        namespace: any;
+        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: any;
-        readonly isInstalled: any;
-        listCatalog: (...args: any[]) => any;
-        catalog: (...args: any[]) => any;
-        listStates: (...args: any[]) => any;
-        states: (...args: any[]) => any;
-        install: (...args: any[]) => any;
-        enable: (...args: any[]) => any;
-        disable: (...args: any[]) => any;
-    };
-    nodes: Record<string, any>;
+        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: any;
+            resolveInteractivePrincipal: (input: import("./control-plane").ResolveInteractivePrincipalInput) => Promise<import("./control-plane").ResolveInteractivePrincipalResponse>;
+        };
+        raw: {
+            identity: {
+                resolveInteractivePrincipal(input: import("./control-plane").ResolveInteractivePrincipalInput): Promise<import("./control-plane").ResolveInteractivePrincipalResponse>;
+            };
         };
-        raw: any;
     };
     identity: {
-        access: any;
-        resolveInteractivePrincipal: any;
-        evaluatePolicy: any;
-        recordPolicyDecision: any;
-        putSecretReference: any;
-        createPrincipal: any;
-        updatePrincipal: any;
-        raw: any;
-        whoami: any;
+        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>>;
+        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>>;
+        };
+        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: any;
-        checkWritePolicy: any;
-        beginBuildSession: any;
-        evaluateEngineeringContract: any;
-        evaluateResearchContract: any;
+        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: any;
-            pollToken: any;
+            createCode: (input?: import("./authDeviceClient").DeviceCodeInput) => Promise<import("./authDeviceClient").DeviceCodeResponse>;
+            pollToken: (deviceCode: string) => Promise<import("./authDeviceClient").DeviceTokenResponse>;
         };
     };
-    custom: any;
-    extensions: any;
+    custom: CustomToolNamespace;
+    extensions: Record<string, CustomToolNamespace>;
     raw: {
-        beliefs: any;
-        sources: any;
-        evidence: any;
-        embeddings: any;
-        eventing: any;
-        graph: Record<string, (...args: any[]) => any> & {
-            create: (...args: any[]) => any;
-            link: (...args: any[]) => any;
-        };
-        graphAnalysis: any;
-        graphRecommendations: any;
-        graphStateClassifier: any;
-        decisions: any;
-        workflow: Record<string, (...args: any[]) => any> & {
-            create: (...args: any[]) => any;
-            link: (...args: any[]) => any;
-        };
-        audit: any;
-        authDevice: any;
-        admin: any;
-        identity: any;
-        policy: Record<string, (...args: any[]) => any> & {
-            create: (...args: any[]) => any;
-            link: (...args: any[]) => any;
-        };
-        answers: any;
-        ontology: any;
-        ontologyLinks: Record<string, (...args: any[]) => any> & {
-            create: (...args: any[]) => any;
-            link: (...args: any[]) => any;
-        };
-        orgGraphSearch: any;
-        functionSurface: any;
-        controlPlane: any;
-        toolRegistry: any;
-        modelRuntime: any;
-        packs: Record<string, (...args: any[]) => any> & {
-            create: (...args: any[]) => any;
-            link: (...args: any[]) => any;
-        };
-        reports: any;
-        learning: any;
-        mcp: any;
-        jobs: any;
-        telemetry: any;
-        harness: any;
-        schema: any;
-        audiences: any;
-        topics: Record<string, (...args: any[]) => any> & {
-            create: (...args: any[]) => any;
-            link: (...args: any[]) => any;
+        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>>;
+            createJudgment(input: import("./decisionsClient").RecordJudgmentInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
+            updateJudgmentOutcome(judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
+        } & {
+            listPendingJudgmentOutcomeReview: (query: import("./decisionsClient").ListPendingJudgmentOutcomeReviewInput) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").PendingJudgmentOutcomeRecord, "reviews">>>;
+            recordJudgment: (input: import("./decisionsClient").RecordJudgmentInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
+            recordJudgmentOutcome: (judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
+        };
+        workflow: {
+            listBranches(query: {
+                topicId?: string;
+                status?: import("./workflowClient").WorkflowBranchStatus;
+                limit?: number;
+            } & import("./types").TopicIdentifierInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowBranchRecord, "branches">>>;
+            createBranch(input: {
+                name: string;
+                topicId?: string;
+                description?: string;
+                metadata?: import("./types").JsonObject;
+            } & import("./types").TopicIdentifierInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowBranchRecord>>;
+            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">>>;
+            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>>;
+            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>>;
+            listWorktrees(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">>>;
+            listAllWorktrees(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>>>;
+            createWorktree(input: import("./workflowClient").AddWorktreeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            merge(worktreeId: string, input: import("./workflowClient").MergeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").MergeWorktreeResponse>>;
+            activateWorktree(worktreeId: string, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            updateWorktreeTargets(input: import("./workflowClient").UpdateWorktreeTargetsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            completeWorktree(input: import("./workflowClient").CompleteWorktreeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            advanceWorktreePhase(input: import("./workflowClient").AdvanceWorktreePhaseInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            setWorktreePhase(input: import("./workflowClient").SetWorktreePhaseInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            patchWorktreeState(input: import("./workflowClient").PatchWorktreeStateInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            bulkCreateWorktrees(input: import("./workflowClient").BulkCreateWorktreesInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+            openPullRequest(worktreeId: string, input: {
+                summary: string;
+                reviewers?: string[];
+                status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").OpenPullRequestResponse>>;
+            push(worktreeId: string, input: {
+                targetContext: string;
+                beliefIds?: string[];
+                metadata?: import("./types").JsonObject;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PushWorktreeResponse>>;
+            listTopics(query?: import("./workflowClient").ListTopicsInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListTopicsResponse>>;
+            switchTopicContext(input: import("./workflowClient").SwitchTopicContextInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").SwitchTopicContextResponse>>;
+            createTask(input: import("./workflowClient").CreateTaskInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").CreateTaskResponse>>;
+            completeTask(taskId: string, input: import("./workflowClient").CompleteTaskInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").CompleteTaskResponse>>;
+            updateTask(taskId: string, input: import("./workflowClient").UpdateTaskInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").UpdateTaskResponse>>;
+        } & {
+            addWorktree: (input: import("./workflowClient").AddWorktreeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            createPillar: (input: {
+                name: string;
+                topicId?: string;
+                description?: string;
+                metadata?: import("./types").JsonObject;
+            } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowBranchRecord>>;
+            createSprint: (input: import("./workflowClient").AddWorktreeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            completeSprint: (worktreeId: string, input: import("./workflowClient").MergeInput, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").MergeWorktreeResponse>>;
+            requestReview: (worktreeId: string, input: {
+                summary: string;
+                reviewers?: string[];
+                status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").OpenPullRequestResponse>>;
+            publishFindings: (worktreeId: string, input: {
+                targetContext: string;
+                beliefIds?: string[];
+                metadata?: import("./types").JsonObject;
+            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PushWorktreeResponse>>;
+        };
+        audit: {
+            listEvents(query?: import("./coreClient").GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
+                limit?: number;
+            } & import("./types").TopicIdentifierInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "events">>>;
+        };
+        authDevice: {
+            createDeviceCode(input?: import("./authDeviceClient").DeviceCodeInput): Promise<import("./authDeviceClient").DeviceCodeResponse>;
+            pollDeviceToken(deviceCode: string): Promise<import("./authDeviceClient").DeviceTokenResponse>;
+        };
+        admin: {
+            listTenants(query?: {
+                status?: "provisioning" | "active" | "disabled" | "suspended" | "archived";
+                limit?: number;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "tenants">>>;
+            createTenant(input: {
+                key: string;
+                slug?: string;
+                name: string;
+                tier?: "free" | "developer" | "team" | "enterprise";
+                status?: "provisioning" | "active" | "disabled" | "suspended" | "archived";
+                ownerClerkId?: string;
+                ownerEmail?: string;
+                lucernDeploymentUrl?: string;
+                appDeploymentUrl?: string;
+                metadata?: import("./types").JsonObject;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            getControlObjectOwnership: () => Promise<import("./coreClient").PlatformGatewaySuccess<import("./controlObjectOwnership").ControlObjectOwnershipContract>>;
+            getControlObjectOwnershipContract: () => Promise<import("./coreClient").PlatformGatewaySuccess<import("./controlObjectOwnership").ControlObjectOwnershipContract>>;
+            listWorkspaces(query?: import("./coreClient").GatewayScope & {
+                status?: "active" | "archived";
+                limit?: number;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "workspaces">>>;
+            createWorkspace(input: import("./coreClient").GatewayScope & {
+                workspaceId?: string;
+                key?: string;
+                slug?: string;
+                name?: string;
+                status?: "active" | "archived";
+                defaultProjectVisibility?: "private" | "team" | "firm" | "external" | "public";
+                restore?: boolean;
+                metadata?: import("./types").JsonObject;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listMemberships(query?: import("./coreClient").GatewayScope & {
+                principalId?: string;
+                status?: "active" | "invited" | "revoked" | "expired";
+                role?: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                limit?: number;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "memberships">>>;
+            createMembership: (input: import("./coreClient").GatewayScope & {
+                membershipId?: string;
+                principalId: string;
+                role: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                status?: "active" | "invited" | "revoked" | "expired";
+                source?: "bootstrap" | "manual" | "sync" | "sso" | "api" | "scim" | "invitation";
+            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            updateMembership: (input: import("./coreClient").GatewayScope & {
+                membershipId?: string;
+                principalId: string;
+                role: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                status?: "active" | "invited" | "revoked" | "expired";
+                source?: "bootstrap" | "manual" | "sync" | "sso" | "api" | "scim" | "invitation";
+            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            upsertMembership: (input: import("./coreClient").GatewayScope & {
+                membershipId?: string;
+                principalId: string;
+                role: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                status?: "active" | "invited" | "revoked" | "expired";
+                source?: "bootstrap" | "manual" | "sync" | "sso" | "api" | "scim" | "invitation";
+            }, idempotencyKey?: string) => Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listTenantApiKeys(scope: import("./coreClient").GatewayScope & {
+                status?: "active" | "revoked" | "expired";
+            }): Promise<{
+                data: {
+                    keys: import("./adminClient").TenantApiKeyRecord[];
+                };
+                correlationId: string;
+                idempotentReplay: boolean;
+                policyTraceId: string | null;
+                success: true;
+            }>;
+            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;
+            }>;
+            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;
+            }>;
+            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;
+            }>;
+            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;
+            }>;
+            deleteTenantVaultSecret(secretId: string, scope: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listTenantSecrets(scope: import("./coreClient").GatewayScope & {
+                providerId?: string;
+                status?: "active" | "revoked";
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            upsertTenantSecret(input: import("./coreClient").GatewayScope & {
+                providerId: string;
+                apiKey: string;
+                label?: string;
+                modelSlotIds?: string[];
+                passThroughOnly?: boolean;
+                metadata?: import("./types").JsonObject;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            revokeTenantSecret(secretRef: string, input: import("./coreClient").GatewayScope & {
+                reason?: string;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            getTenantConfig(scope: import("./coreClient").GatewayScope & {
+                tenantId: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./adminClient").TenantConfigRecord>>;
+            getTenantModelRouting(scope: import("./coreClient").GatewayScope & {
+                tenantId: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./adminClient").TenantModelRoutingSnapshot>>;
+            upsertTenantConfig(input: import("./coreClient").GatewayScope & Omit<import("./adminClient").TenantConfigRecord, "updatedAt" | "updatedBy">, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./adminClient").TenantConfigRecord>>;
+            listGroups(scope?: import("./coreClient").GatewayScope & {
+                limit?: number;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            createGroup(input: import("./coreClient").GatewayScope & {
+                name: string;
+                groupKey?: string;
+                groupType?: string;
+                description?: string;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            updateGroup(groupId: string, input: import("./coreClient").GatewayScope & {
+                name?: string;
+                description?: string;
+                workspaceId?: string;
+                clearWorkspaceId?: boolean;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            deleteGroup(groupId: string, input?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listGroupMembers(query: import("./coreClient").GatewayScope & {
+                groupId: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            addGroupMember(input: import("./coreClient").GatewayScope & {
+                groupId: string;
+                principalId: string;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            removeGroupMember(input: import("./coreClient").GatewayScope & {
+                groupId: string;
+                principalId: string;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            listPackGroupAssignments(query?: import("./coreClient").GatewayScope & {
+                groupId?: string;
+                status?: string;
+            }): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            assignPackToGroup(input: import("./coreClient").GatewayScope & {
+                groupId: string;
+                packKey: string;
+                packVersion?: string;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+            removePackFromGroup(input: import("./coreClient").GatewayScope & {
+                groupId: string;
+                packKey: string;
+            }, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+        };
+        identity: {
+            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>>;
+        };
+        policy: {
+            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;
+            }>;
+        };
+        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: any;
-        record: any;
-        list: any;
-        get: any;
-        recordOutcome: any;
-        updateOutcome: any;
-        readiness(topicId: string): any;
-        calibration(topicId: string): any;
-        pendingOutcomeReview(topicId: string): any;
+        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;
-        }): any;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").JudgmentTransitionAuditIntegrityResponse>>;
     };
     decisions: {
-        create: any;
-        record: any;
-        list: any;
-        get: any;
-        recordOutcome: any;
-        lessons(decisionId: string, input: import("./types").JsonObject, idempotencyKey?: string): Promise<any>;
-        archive(decisionId: string, input?: import("./types").JsonObject, idempotencyKey?: string): Promise<any>;
-        readiness(topicId: string): any;
-        calibration(topicId: string): any;
-        pendingOutcomeReview(topicId: string): any;
+        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: (...args: any[]) => any;
-        createLens: (...args: any[]) => any;
-        listLenses: (...args: any[]) => any;
-        applyLensToTopic: (...args: any[]) => any;
-        removeLensFromTopic: (...args: any[]) => any;
-        create(input: import("./workflowClient").AddWorktreeInput): any;
-        add(input: import("./workflowClient").AddWorktreeInput): any;
-        list(query: Parameters<(...args: any[]) => any>[0]): any;
-        listByTopic(query: Parameters<(...args: any[]) => any>[0]): any;
+        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<any>;
-        activate(worktreeId: string): any;
-        updateMetadata(input: import("./functionSurface").FunctionSurfaceInput): any;
-        update(input: import("./functionSurface").FunctionSurfaceInput): any;
-        updateTargets(input: Parameters<(...args: any[]) => any>[0]): any;
-        listAll: (...args: any[]) => any;
-        merge(worktreeId: string, input: import("./workflowClient").MergeInput): any;
-        push: (...args: any[]) => any;
-        openPullRequest: (...args: any[]) => any;
-        pipelineSnapshot(topicId: string): any;
-        complete: (...args: any[]) => any;
-        advancePhase(worktreeId: string, idempotencyKey?: string): any;
-        setPhase(worktreeId: string, phase: string, idempotencyKey?: string): any;
-        patchState: (...args: any[]) => any;
-        bulkCreate: (...args: any[]) => any;
+        }): 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<(...args: any[]) => any>[0]): any;
-        compile: any;
-        recordScopeLearning: any;
-        discover(input: import("./functionSurface").FunctionSurfaceInput): any;
-        analyzeTopicDensity: any;
-        applyAutoBranching: any;
-        seedBeliefLattice: any;
-        getLatticeCoverage: any;
-        matchEntityType(input: import("./functionSurface").FunctionSurfaceInput): any;
-        discoverEntityConnections(input: import("./functionSurface").FunctionSurfaceInput): any;
-        triggerBeliefReview(input: import("./functionSurface").FunctionSurfaceInput): any;
+        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): any;
-        complete(taskId: string, input: import("./workflowClient").CompleteTaskInput): any;
-        update(taskId: string, input: import("./workflowClient").UpdateTaskInput): any;
-        list(input: import("./functionSurface").FunctionSurfaceInput): any;
+        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;
-        }): any;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<import("./gatewayFacades").TaskListResult>>;
         listByWorktree(input: import("./functionSurface").FunctionSurfaceInput & {
             worktreeId: string;
-        }): any;
-        linkChat(taskId: string, input: import("./types").JsonObject, idempotencyKey?: string): Promise<any>;
+        }): 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<(...args: any[]) => any>[0]): any;
-        get: (...args: any[]) => any;
-        create(input: Parameters<(...args: any[]) => any>[0]): any;
-        update(topicId: string, input: Parameters<(...args: any[]) => any>[1]): any;
-        tree(topicId: string, query?: Parameters<(...args: any[]) => any>[1]): any;
+        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;
-        }): any;
-        coverage(topicId: string, query?: Parameters<(...args: any[]) => any>[1]): any;
-        remove: (...args: any[]) => any;
-        bulkCreate: (...args: any[]) => any;
-        materializeGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        materializeTopicGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        graphSpine(input?: import("./functionSurface").FunctionSurfaceInput): any;
-        getTopicGraphSpine(input?: import("./functionSurface").FunctionSurfaceInput): any;
+        }): 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): any;
-        get(input: import("./functionSurface").FunctionSurfaceInput): any;
+        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: {
@@ -306,82 +1770,133 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             topicId?: string;
             severity?: string;
             defeatType?: string;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
         list(args: {
             topicId?: string;
             status?: string;
             limit?: number;
             cursor?: string;
-        }): any;
-        get(contradictionId: string): any;
-        find: any;
+        }): 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;
-        }): any;
-        get(ontologyId: string): any;
-        bind(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: Parameters<(...args: any[]) => any>[1]): any;
-        match(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: Parameters<(...args: any[]) => any>[1]): any;
-        create(input: import("./functionSurface").FunctionSurfaceInput): any;
-        update(input: import("./functionSurface").FunctionSurfaceInput): any;
-        archive(input: import("./functionSurface").FunctionSurfaceInput): any;
-        createVersion(input: import("./functionSurface").FunctionSurfaceInput): any;
-        publishVersion(input: import("./functionSurface").FunctionSurfaceInput): any;
-        publishOntologyVersion(input: import("./functionSurface").FunctionSurfaceInput): any;
-        deprecateVersion(input: import("./functionSurface").FunctionSurfaceInput): any;
-        deprecateOntologyVersion(input: import("./functionSurface").FunctionSurfaceInput): any;
-        resolveEffective(input: import("./functionSurface").FunctionSurfaceInput): any;
-        resolveEffectiveOntology(input: import("./functionSurface").FunctionSurfaceInput): any;
-        raw: any;
+        }): 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: {
+            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">>>;
+        };
     };
     graph: {
-        nodes: Record<string, any>;
-        createEdge: (...args: any[]) => any;
-        neighborhood(args: Parameters<(...args: any[]) => any>[0]): any;
-        queryLineage: any;
-        getConfidenceHistory: any;
-        getOpinionHistory: any;
-        getAuditTrail: any;
+        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;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
         analyze(args: {
             topicId?: string;
             limit?: number;
             metric?: string;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
         bias(args: {
             topicId?: string;
             threshold?: number;
             limit?: number;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
         gaps(args: {
             topicId?: string;
             minConfidence?: number;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
         falsify(args: {
             topicId?: string;
             beliefId?: string;
             beliefIds?: string[];
             minConfidence?: number;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
         traceEntityImpact(args: {
             nodeId: string;
             topicId?: string;
-        }): any;
-        searchBeliefs: any;
-        findContradictions: any;
-        bisectConfidence: any;
-        listBeliefs: any;
-        detectConfirmationBias(topicId: string, threshold?: number): any;
-        getStructureAnalysis(topicId: string): any;
-        getFalsificationQuestions(topicId: string, beliefIds?: string[]): any;
+        }): 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: {
@@ -390,7 +1905,7 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             query?: string;
             limit?: number;
             cursor?: string;
-        }): Promise<any>;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
     graphSearch: {
         keywordSearchNodes(input: {
@@ -402,7 +1917,7 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             nodeTypes?: string[];
             limit?: number;
             cursor?: string;
-        }): Promise<any>;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
     classifiers: {
         listBeliefCandidates(input: {
@@ -412,43 +1927,71 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             query?: string;
             limit?: number;
             cursor?: string;
-        }): Promise<any>;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
     archetypes: {
         getJudgmentSignature(input: {
             topicId?: string;
             projectId?: string;
             principalId?: string;
-        }): Promise<any>;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
     events: {
-        list(query?: Parameters<(...args: any[]) => any>[0]): any;
-        replay(input: Parameters<(...args: any[]) => any>[0]): any;
-        recordEvent: any;
-        listEvents: any;
-        listWebhooks: any;
-        enqueueDelivery: any;
-        recordDeliveryAttempt: any;
-        updateDeliveryStatus: any;
+        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("./clientConfig").BeliefsCompatCreateInput): any;
-        get(nodeId: string): any;
+        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): any;
-        updateRationale(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        linkBeliefs(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        unlinkEvidence(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        updateCriticality(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        batchUpdateCriticality(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        reassignTopic(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        fork(nodeId: string, input: import("./clientConfig").BeliefsCompatForkInput): any;
+        }, 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;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
         list(args: {
             topicId?: string;
             worktreeId?: string;
@@ -456,23 +1999,23 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             minConfidence?: number;
             limit?: number;
             cursor?: string;
-        }): any;
-        search: any;
-        lineage(nodeId: string): any;
-        confidenceHistory(nodeId: string): any;
-        opinionHistory: any;
-        createContract(nodeId: string, input: Parameters<(...args: any[]) => any>[1]): any;
-        bisect(nodeId: string, input: Parameters<(...args: any[]) => any>[1]): any;
+        }): 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<(...args: any[]) => any>[0]): any;
-        list(query?: Parameters<(...args: any[]) => any>[0]): any;
-        get(id: string): any;
-        update(id: string, input: Parameters<(...args: any[]) => any>[1]): any;
-        delete(id: string): any;
-        test(id: string, input?: Parameters<(...args: any[]) => any>[1]): any;
-        deliveries(id: string, query?: Parameters<(...args: any[]) => any>[1]): any;
-        health(id: string): any;
+        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 & {
@@ -486,40 +2029,42 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             weight?: number;
             context?: string;
             reasoning?: string;
-        }, idempotencyKey?: string): any;
-        createEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        update(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        updateEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        remove(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        removeEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        removeBetween(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        removeEdgesBetween(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        batchCreate(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        batchCreateEdges(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
-        delete(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
+        }, 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;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayList>>;
         traverse(args: {
             startNode: string;
             direction?: string;
             maxDepth?: number;
             topicId?: string;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
     };
     evidence: {
-        create(args: import("./clientEvidenceCompat").EvidenceCompatInput): any;
-        add: any;
-        get(evidenceId: string): any;
+        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;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayList>>;
         search(args: {
             q?: string;
             query?: string;
@@ -528,7 +2073,7 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             methodology?: string;
             limit?: number;
             cursor?: string;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayList>>;
         link(args: {
             evidenceId: string;
             targetId?: string;
@@ -539,7 +2084,7 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             evidenceRelation?: "supports" | "contradicts";
             confidence?: number;
             rationale?: string;
-        }): any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").EvidenceLinkResult>>;
         linkToBelief(args: {
             evidenceId: string;
             beliefId: string;
@@ -547,18 +2092,20 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             evidenceRelation?: "supports" | "contradicts";
             confidence?: number;
             rationale?: string;
-        }): any;
-        classifyEvidence(beliefId: string, evidenceId: string, config?: Parameters<any>[2], idempotencyKey?: string): any;
-        classifyEvidenceBatch(beliefId: string, evidence: Parameters<any>[1], config?: Parameters<any>[2], idempotencyKey?: string): any;
-        updateStatus(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        update(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        flagIncorrect(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        remove(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        updateVerificationStatus(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
+        }): 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>>;
     };
     sources: {
-        upsert(input: Parameters<any>[0], idempotencyKey?: Parameters<any>[1]): any;
-        get(sourceId: string): any;
+        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>>;
     };
     questions: {
         create(args: {
@@ -567,14 +2114,14 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             priority?: string;
             linkedBeliefId?: string;
             metadata?: import("./types").JsonObject;
-        }): any;
-        get(questionId: string): any;
+        }): 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): any;
+        }, refinementReason?: string): Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
         list(args: {
             topicId?: string;
             status?: string;
@@ -582,39 +2129,46 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             worktreeId?: string;
             limit?: number;
             cursor?: string;
-        }): any;
-        updateStatus(questionId: string, status: string, rationale?: string): any;
-        batchCreate(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        add(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        updatePriority(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        advanceToConviction(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        updateConviction(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        finalizeConviction(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        update(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        delete(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
+        }): 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;
-        }): any;
-        archive(questionId: string, reason?: string): any;
+        }): 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;
-        }): any;
+        }): Promise<{
+            questionId: string;
+            relevance: number | undefined;
+        }>;
         getHighPriority(args: {
             topicId?: string;
             limit?: number;
             includeAnswered?: boolean;
-        }): any;
+        }): Promise<{
+            questions: ({
+                priority?: string;
+            } & Record<string, unknown>)[];
+        }>;
         findMissing(args: {
             topicId?: string;
             minConfidence?: number;
-        }): Promise<any>;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
     config: LucernClientConfig;
     version: string;
@@ -625,6 +2179,6 @@ export declare function createLucernClient(config?: LucernClientConfig): {
         minConfidence?: number;
         limit?: number;
         cursor?: string;
-    }) => Promise<any>;
+    }) => Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").SearchResult>>;
 };
 //# sourceMappingURL=client.d.ts.map