@lucern/sdk 1.0.29 → 1.0.30

package/dist/clientPlatformNamespaces.d.ts

@@ -1,92 +1,348 @@
-import type { ClientNamespaceContext } from "./clientAssemblyTypes";
-import type { CustomToolInput } from "./clientConfig";
+import type { ClientNamespaceContext } from "./client-assembly-types";
+import type { CustomToolInput } from "./client-config";
 import type { FunctionSurfaceInput } from "./generated/functionSurface";
+import type { JsonObject } from "./types";
 export declare function createClientPlatformNamespaces(ctx: ClientNamespaceContext): {
     coordination: {
-        registerSession: any;
-        heartbeatSession: any;
-        endSession: any;
-        listActiveSessions: any;
-        sendAgentMessage: any;
-        broadcastMessage: any;
-        getInbox: any;
-        getAgentInbox: any;
-        claimFiles: any;
+        registerSession: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        heartbeatSession: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        endSession: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        listActiveSessions: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        sendAgentMessage: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        broadcastMessage: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getInbox: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getAgentInbox: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        claimFiles: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
     };
     policy: {
-        checkPermission(input: FunctionSurfaceInput): any;
-        listAccessibleTopics(input?: Parameters<(...args: any[]) => any>[0]): any;
-        filterByPermission(input: FunctionSurfaceInput): any;
-        compileCapabilitySlice(input: Parameters<any>[0], idempotencyKey?: string): any;
-        manageWritePolicy(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        raw: Record<string, (...args: any[]) => any> & {
-            create: (...args: any[]) => any;
-            link: (...args: any[]) => any;
+        checkPermission(input: 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: FunctionSurfaceInput): Promise<{
+            success: true;
+            data: import("./policyClient").FilterByPermissionResponse;
+        }>;
+        compileCapabilitySlice(input: Parameters<(input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>>[0], idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+        manageWritePolicy(input: 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?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        ingestObservation: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getContext: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getObservationContext: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
     };
     coding: {
-        getCodeContext: any;
-        getChangeHistory: any;
-        recordAttempt: any;
-        getFailureLog: any;
+        getCodeContext: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getChangeHistory: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        recordAttempt: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        getFailureLog: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
     };
     contracts: {
-        create(input: FunctionSurfaceInput): any;
-        createEpistemicContract(input: FunctionSurfaceInput): any;
+        create(input: FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        createEpistemicContract(input: FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
         list(input?: {
             beliefNodeId?: string;
             contractId?: string;
             status?: string;
-        }): any;
-        evaluate(input: FunctionSurfaceInput): any;
-        evaluateContract(input: FunctionSurfaceInput): any;
-        getStatus(input: FunctionSurfaceInput): any;
-        getContractStatus(input: FunctionSurfaceInput): any;
+        }): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        evaluate(input: FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        evaluateContract(input: FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        getStatus(input: FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        getContractStatus(input: FunctionSurfaceInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
     };
     bootstrap: {
-        generateSessionHandoff: any;
+        generateSessionHandoff: (input?: 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?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        hybridDiscover: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        resolveTopicSemantic: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        expandGraphNeighborhood: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        findRelatedNodes: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        analyzeGraphImpact: (input?: FunctionSurfaceInput, idempotencyKey?: string) => import("./functionSurface").FunctionSurfaceResult<unknown>;
+        detectGraphDrift: (input?: 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?: 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 import("./customTools").registerCustomTool;
+        unregister: typeof import("./customTools").unregisterCustomTool;
+        list: typeof import("./customTools").listRegisteredCustomTools;
+        clear: typeof import("./customTools").clearRegisteredCustomTools;
+        invoke(name: string, input?: CustomToolInput): Promise<unknown>;
+        namespace: (namespace: string) => import("./client-config").CustomToolNamespace;
     };
     packs: {
         /**
@@ -94,104 +350,1239 @@ export declare function createClientPlatformNamespaces(ctx: ClientNamespaceConte
          * No-op if no packKey was provided or if the pack is already installed.
          * Called automatically on first API use when packKey is set.
          */
-        ensurePack: any;
+        ensurePack: () => Promise<void>;
         /**
          * Check if the configured pack has been installed in this session.
          */
-        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>;
+        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?: 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?: 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?: 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?: 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?: 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?: 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: import("./client-config").CustomToolNamespace;
+    extensions: Record<string, import("./client-config").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?: 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?: JsonObject;
+            } & import("./types").TopicIdentifierInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").WorkflowLensRecord>>;
+            applyLensToTopic(input: {
+                lensId: string;
+                topicId?: string;
+                metadata?: 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?: 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?: 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?: 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?: 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?: 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?: 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?: 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?: 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?: 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?: 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?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            addEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            addWorktree(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            analyzeGraphImpact(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            analyzeTopicDensity(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            answerQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            appendSlScoring(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            applyAutoBranching(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            applyLensToTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            applyOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            archiveBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            archiveEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            archiveEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            archiveOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            archiveQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            batchCreateEdges(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            batchCreateEpistemicNodes(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            beginBuildSession(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            bisectConfidence(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            broadcastMessage(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            checkPermission(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            claimFiles(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            compileCapabilitySlice(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            compileContext(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            completeTask(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createAnswer(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createEdge(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createEpistemicContract(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createLens(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createOntologyVersion(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createTask(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            createTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            deprecateOntologyVersion(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            detectConfirmationBias(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            detectGraphDrift(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            discover(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            discoverEntityConnections(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            endSession(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            evaluateContract(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            expandGraphNeighborhood(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            expandNarrative(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            filterByPermission(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            findContradictions(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            findMissingQuestions(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            findRelatedNodes(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            flagContradiction(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            forkBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            generateSessionHandoff(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getAgentInbox(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getAnswer(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getAuditTrail(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getCampaignContext(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getChangeHistory(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getCodeContext(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getConfidenceHistory(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getContractStatus(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getByNodeIds(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getFailureLog(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getFalsificationQuestions(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getGraphGaps(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getGraphNeighborhood(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getGraphStructureAnalysis(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getHighPriorityQuestions(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getLatticeCoverage(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getLoadBearingNodes(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getObservationContext(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getOperatorGauntlet(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getReasoningExemplars(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getTopicCoverage(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getTopicGraphSpine(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getTopicTree(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            getWorktree(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            heartbeatSession(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            hybridDiscover(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            whoami(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            ingestObservation(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            linkEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            linkEvidenceToBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            linkEvidenceToQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listActiveSessions(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listAllWorktrees(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listBeliefs(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listCampaigns(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listEpistemicNodes(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listGraphIntelligenceQueries(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listLenses(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listMissingForTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listOntologies(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listQuestions(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listTasks(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listTopics(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listWorktrees(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            listWorktreesByBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            lucernOrient(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            manageWritePolicy(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            matchEntityType(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            materializeTopicGraph(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            merge(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            openPullRequest(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            pipelineSnapshot(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            publishOntologyVersion(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            push(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            queryAnchorHistory(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            queryLineage(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            markEmbeddingBackfillQueued(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            recordAttempt(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            recordJudgment(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            recordScopeLearning(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            refineBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            refineQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            registerSession(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            removeEdge(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            removeEdgesBetween(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            removeLensFromTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            resolveEffectiveOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            resolveInteractivePrincipal(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            resolveTopicSemantic(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            runGraphIntelligenceQuery(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            searchBeliefs(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            vectorSearchByTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            searchEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            seedBeliefLattice(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            sendAgentMessage(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            supersedeEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            traceEntityImpact(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            traverseGraph(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            triggerBeliefReview(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateEdge(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateQuestionStatus(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateTask(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateWorktreeMetadata(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            updateWorktreeTargets(input?: FunctionSurfaceInput, idempotencyKey?: string): import("./functionSurface").FunctionSurfaceResult<unknown>;
+            verifyEpistemicNode(input?: 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>>>;
         };
     };
 };