@lucern/sdk 0.3.0-alpha.1 → 0.3.0-alpha.11

package/dist/client.d.ts

@@ -1,32 +1,2993 @@
-import './audiencesClient.js';
-import './schemaClient.js';
-import './harnessClient.js';
-import './identityClient.js';
-import './adminClient.js';
-import './controlObjectOwnership.js';
-import './beliefsClient.js';
-import './packsClient.js';
-import './customTools.js';
-import './policyClient.js';
-import './coreClient.js';
-import './ontologyClient.js';
-import './contextTypes.js';
-import './topicsClient.js';
-import './answersClient.js';
-import './auditClient.js';
-export { L as LucernClientConfig, c as createLucernClient } from './client-B6aWUUwp.js';
-import './contextClient.js';
-import './contracts/lens-workflow.contract.js';
-import './decisionsClient.js';
-import './evidenceClient.js';
-import './graphClient.js';
-import './learningClient.js';
-import './reportsClient.js';
-import './types.js';
-import './sourcesClient.js';
-import './workflowClient.js';
+import { AudiencesClientConfig, AudienceRegistryInput, AudienceGrantInput, AudienceGrantRevokeInput } from './audiencesClient.js';
+import { SchemaClientConfig, SchemaPackInstallInput, SchemaEntitlementInput } from './schemaClient.js';
+import { HarnessClientConfig, HarnessAgentWriteInput, HarnessInvokeManagedAgentInput, HarnessToolWriteInput, HarnessExecuteToolInput, HarnessExecuteToolResult, HarnessStartRunInput, HarnessRunReportInput, HarnessCompleteRunInput } from './harnessClient.js';
+import { AdminClientConfig, TenantApiKeyRecord, TenantVaultSecretRecord, TenantConfigRecord, TenantModelRoutingSnapshot } from './adminClient.js';
+import { ControlObjectOwnershipContract } from './controlObjectOwnership.js';
+import { BeliefsClientConfig, ModulateConfidenceInput, OpinionHistoryEntry, CreateBeliefInput, RefineBeliefInput, ModulateConfidenceOpinionInput, ForkBeliefInput, UpdateBeliefStatusInput, UpdateBeliefRationaleInput, LinkBeliefsInput, UnlinkBeliefEvidenceInput, UpdateBeliefCriticalityInput, BatchUpdateBeliefCriticalityInput, ReassignBeliefsTopicInput } from './beliefsClient.js';
+import { DeviceCodeInput, DeviceCodeResponse, DeviceTokenResponse } from './authDeviceClient.js';
+import { McpBootstrapSessionInput, McpBootstrapSessionResponse, McpCheckWritePolicyInput, McpCheckWritePolicyResponse, McpBeginBuildSessionInput, McpBeginBuildSessionResponse, McpEvaluateEngineeringContractInput, McpContractEvaluationResponse, McpEvaluateResearchContractInput } from './mcpClient.js';
+import { IdentityClientConfig, PolicyEvaluationInput, PolicyDecisionRecord, RecordPolicyDecisionInput, PutTenantSecretReferenceInput, TenantSecretReference, ClerkUserSearchResult, TenantIdentityScope, TenantIdentityConfigRecord, UpdateTenantConfigInput, TenantIntegrationRecord, UpsertTenantIntegrationInput } from './identityClient.js';
+import { normalizeCanonicalPrincipalIdentity, RequireAccessInput, AccessCheckResult } from './accessControl.js';
+import { PacksClientConfig, PackInstallInput, PackEnableInput, PackDisableInput, PackEntitlementInput, PackUninstallInput, PackUpgradeInput } from './packsClient.js';
+import { ToolRegistryClientConfig, ToolRegistryQuery, ToolCatalogEntry, EffectiveToolsQuery, UpsertCoreToolsInput, SetPackToolsStatusInput, CreateToolAclInput, ToolAclRecord, DeleteToolAclInput, RegisterCustomToolInput } from './toolRegistryClient.js';
+import { TelemetryClientConfig, LogSystemEventInput, LogToolCallsBatchInput, RecordEpistemicAuditInput, RecordTelemetryPolicyDecisionInput, StartTelemetryRunInput, TelemetryRunRecord, FinishTelemetryRunInput, TelemetryScope } from './telemetryClient.js';
+import { JobsClientConfig, EnqueueJobInput, JobRecord, JobsScope, ClaimJobInput, UpdateJobStatusInput, RetryJobInput, RecordJobRunStartInput, JobRunRecord, RecordJobRunFinishInput } from './jobsClient.js';
+import { ModelRuntimeClientConfig, ModelRuntimeScope, ModelRegistryRecord, ModelFunctionSlot, ResolveModelSlotInput, UpdateModelSlotConfigInput } from './modelRuntimeClient.js';
+import { GraphStateClassifierClientConfig, ClassifyNodeInput, GraphStateClassification, ClassifyTopicInput, ListGraphStateClassificationsInput, RecordGraphStateClassificationInput } from './graphStateClassifierClient.js';
+import { OntologyLinksClientConfig, OntologyLinkWriteInput, OntologyLinkRecord, ListOntologyLinksForNodeInput, UpdateOntologyLinkStatusInput } from './ontologyLinksClient.js';
+import { OrgGraphSearchClientConfig, OrgGraphSearchInput, OrgGraphSearchResponse, GetOrgGraphNodeInput, OrgGraphSearchResult, ListOrgGraphByProvenanceInput, ListPublishedFromWorkspaceInput } from './orgGraphSearchClient.js';
+import { GraphRecommendationsClientConfig, GraphRecommendationListInput, GraphRecommendationRecord, MarkGraphRecommendationStatusInput } from './graphRecommendationsClient.js';
+import { GraphAnalysisClientConfig, ListGraphIntelligenceQueriesInput, GraphIntelligenceQueryCatalogResponse, RunGraphIntelligenceQueryInput, GraphIntelligenceQueryRunResponse, SaveGraphAnalysisInput, GraphAnalysisRecord, ListGraphAnalysesInput, GetLatestGraphAnalysisInput, SaveGraphSuggestionsInput, GraphAnalysisSuggestionsResponse, UpdateGraphSuggestionStatusInput, GraphAnalysisSuggestion, ListGraphSuggestionsInput, ListGraphChangesInput, ComputeOrRequestGraphAnalysisInput } from './graphAnalysisClient.js';
+import { EmbeddingsClientConfig, GetEmbeddingsByNodeIdsInput, EmbeddingRecord, ListMissingEmbeddingsInput, MissingEmbeddingCandidate, VectorSearchByTopicInput, VectorSearchMatch, MarkEmbeddingBackfillQueuedInput } from './embeddingsClient.js';
+import { PolicyClientConfig, PermissionDecision, PermissionKind, WritePolicyRecord, WritePolicyCreateInput, WritePolicyUpdateInput, TenantPolicyRecord, TenantPolicyPermission } from './policyClient.js';
+import { PlatformGatewaySuccess, GatewayScope } from './coreClient.js';
+import { OntologyClientConfig, OntologyBindingInput, OntologyDefinitionInput, OntologyDefinitionUpdateInput, OntologyVersionInput } from './ontologyClient.js';
+import { CompileContextInput, PublicCompiledContext } from './contextTypes.js';
+import { TopicsClientConfig, TopicListInput, TopicCreateInput, TopicUpdateInput, TopicTreeQuery, TopicCoverageQuery, TopicBulkCreateInput } from './topicsClient.js';
+import { FunctionSurfaceClientConfig, FunctionSurfaceInput, FunctionSurfaceResult } from './functionSurface.js';
+import { AnswersClientConfig } from './answersClient.js';
+import { AuditClientConfig } from './auditClient.js';
+import { ListResult, JsonObject, PlatformSourceRecord, PlatformGraphNode, PlatformGraphEdge, GraphNeighborhoodResponse, JsonArray, RecordJudgmentResponse, ListJudgmentsResponse, GetJudgmentResponse, RecordJudgmentOutcomeResponse, JudgmentReadinessResponse, JudgmentCalibrationResponse, PendingJudgmentOutcomeRecord, JudgmentTransitionAuditIntegrityResponse, TopicIdentifierInput, WorkflowBranchRecord, WorkflowLensRecord, WorkflowLensBindingRecord, WorkflowWorktreeRecord, ListWorktreesResponse, PushWorktreeResponse, OpenPullRequestResponse, TopicListResponse, TopicRecord, TopicTreeResponse, TopicCoverageResponse, PlatformBeliefRecord, ModulateConfidenceResponse, ForkBeliefResponse, DeleteEdgeResponse, GraphPathResponse, GraphAnalyticsResponse, MergeWorktreeResponse, ListTopicsResponse, SwitchTopicContextResponse, CreateTaskResponse, CompleteTaskResponse, UpdateTaskResponse, ReportTemplatesResponse, ReportWithSectionsResponse } from './types.js';
+import { ContextClientConfig } from './contextClient.js';
+import { LensPromptTemplateReference, LensWorkflowTemplate, LensTaskTemplate } from './contracts/lens-workflow.contract.js';
+import { registerCustomTool, unregisterCustomTool, listRegisteredCustomTools, clearRegisteredCustomTools } from './customTools.js';
+import { DecisionsClientConfig, RecordJudgmentInput, ListJudgmentsInput, RecordJudgmentOutcomeInput, GetJudgmentCalibrationInput, ListPendingJudgmentOutcomeReviewInput, GetJudgmentTransitionAuditIntegrityInput } from './decisionsClient.js';
+import { EvidenceClientConfig, EvidenceClassificationRequestConfig, ClassifyEvidenceResult, ClassifyEvidenceBatchItem, ClassifyEvidenceBatchResult } from './evidenceClient.js';
+import { EventingClientConfig, RecordEventInput, EventingRecord, EventingScope, EventingWebhookRecord, EnqueueDeliveryInput, EventingDeliveryRecord, RecordDeliveryAttemptInput, UpdateDeliveryStatusInput } from './eventingClient.js';
+import { GraphClientConfig, ListNodesInput, GetNodeInput, HardDeleteNodeInput, CreateEdgeInput, NeighborhoodInput, CreateNodeInput, UpdateNodeInput, BatchCreateNodesInput, SupersedeNodeInput, VerifyNodeInput, ListEdgesInput, DeleteEdgeInput, TraverseInput, AnalyzeInput, BiasInput, GapsInput, SearchInput, PathInput, AnalyticsInput } from './graphClient.js';
+import { LearningClientConfig } from './learningClient.js';
+import { ReportsClientConfig } from './reportsClient.js';
+import { SourcesClientConfig, UpsertSourceSpec } from './sourcesClient.js';
+import { WorkflowClientConfig, WorkflowLensPerspectiveType, WorkflowLensStatus, AddWorktreeInput, WorkflowWorktreeStatus, UpdateWorktreeTargetsInput, MergeInput, CreateTaskInput, CompleteTaskInput, UpdateTaskInput, WorkflowBranchStatus, CompleteWorktreeInput, AdvanceWorktreePhaseInput, SetWorktreePhaseInput, PatchWorktreeStateInput, BulkCreateWorktreesInput, ListTopicsInput, SwitchTopicContextInput } from './workflowClient.js';
+import { CustomToolInput as CustomToolInput$1 } from './clientHelpers.js';
+import './authContext.js';
+import './contracts/auth-session.contract.js';
 import './contracts/workflow-runtime.contract.js';
 import './contracts/lens-filter.contract.js';
 import './opinion.js';
+import '@lucern/contracts/mcp-gateway-boundary.contract';
+import './boundaryClientSurface.js';
+import '@lucern/contracts';
 import 'zod';
 import '@lucern/contracts/tool-contracts';
+
+type ClientConfig = BeliefsClientConfig | SourcesClientConfig | GraphClientConfig | DecisionsClientConfig | AnswersClientConfig | ContextClientConfig | WorkflowClientConfig | AuditClientConfig | AdminClientConfig | EvidenceClientConfig | EmbeddingsClientConfig | EventingClientConfig | GraphAnalysisClientConfig | GraphRecommendationsClientConfig | GraphStateClassifierClientConfig | IdentityClientConfig | JobsClientConfig | ModelRuntimeClientConfig | OntologyLinksClientConfig | OrgGraphSearchClientConfig | PolicyClientConfig | PacksClientConfig | ReportsClientConfig | LearningClientConfig | TelemetryClientConfig | ToolRegistryClientConfig | FunctionSurfaceClientConfig | OntologyClientConfig | HarnessClientConfig | SchemaClientConfig | AudiencesClientConfig | TopicsClientConfig;
+type CustomToolInput = CustomToolInput$1;
+type CustomToolInvoker = (input?: CustomToolInput) => Promise<unknown>;
+type CustomToolNamespace = Record<string, CustomToolInvoker>;
+type GatewayDataEnvelope<T = unknown> = PlatformGatewaySuccess<T> & (T extends Record<string, unknown> ? T : Record<string, unknown>);
+type BeliefsCompatCreateInput = {
+    topicId?: string;
+    text?: string;
+    canonicalText?: string;
+    formulation?: string;
+    rationale?: string;
+    worktreeId?: string;
+    pillar?: string;
+    baseRate?: number;
+    sourceBeliefIds?: string[];
+    sourceType?: string;
+    beliefType?: string;
+    reversibility?: string;
+    predictionMeta?: JsonObject;
+    metadata?: JsonObject;
+};
+type BeliefsCompatForkInput = {
+    text?: string;
+    newFormulation?: string;
+    formulation?: string;
+    forkReason?: "refinement" | "contradiction_response" | "scope_change" | "confidence_collapse" | "manual";
+    rationale?: string;
+};
+type BeliefsCompatUpdateConfidenceInput = ModulateConfidenceInput;
+/**
+ * Configuration for the high-level Lucern SDK client.
+ *
+ * At minimum, provide `apiKey` and `baseUrl`. The SDK handles
+ * authentication, retries, and idempotency automatically.
+ */
+type LucernClientConfig = ClientConfig & {
+    /** API key for authenticating with the Lucern platform. */
+    apiKey?: string;
+    /**
+     * Optional Clerk JWT for per-user identity and RBAC.
+     * When present, the SDK operates in user-scoped mode with
+     * pack-aware tool filtering. When absent, operates in agent mode.
+     */
+    /** Lucern platform session token for interactive/user-scoped requests. */
+    userToken?: string;
+    /**
+     * Optional pack key for auto-install convenience.
+     * When set, the SDK will call `packs.install()` on first use
+     * to ensure the pack is available in the workspace.
+     */
+    packKey?: string;
+    /** Target environment. Defaults to production if not specified. */
+    environment?: "sandbox" | "production";
+};
+/**
+ * Create the high-level Lucern SDK client with all domain namespaces.
+ *
+ * @param config - Client configuration with API key, base URL, and optional settings.
+ * @returns The Lucern client with namespaced methods for beliefs, topics, evidence, decisions, and more.
+ */
+declare function createLucernClient(config?: LucernClientConfig): {
+    config: LucernClientConfig;
+    version: string;
+    search: (query: string, options?: {
+        topicId?: string;
+        types?: string[];
+        status?: string;
+        minConfidence?: number;
+        limit?: number;
+        cursor?: string;
+    }) => Promise<GatewayDataEnvelope<{
+        [x: string]: unknown;
+    } & {
+        cursor?: string;
+        total?: number;
+    } & {
+        beliefs?: {
+            [x: string]: unknown;
+        }[];
+        results?: {
+            [x: string]: unknown;
+        }[];
+    }>>;
+    events: {
+        list(query?: Parameters<(query?: {
+            topicId?: string;
+            after?: string;
+            types?: string[];
+            startTime?: number;
+            endTime?: number;
+            limit?: number;
+        }) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            events?: {
+                [x: string]: unknown;
+            }[];
+        }>>>[0]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            events?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        replay(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        recordEvent: (input: RecordEventInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<EventingRecord>>;
+        listEvents: (input: EventingScope) => Promise<PlatformGatewaySuccess<ListResult<EventingRecord, "events">>>;
+        listWebhooks: (input: EventingScope) => Promise<PlatformGatewaySuccess<ListResult<EventingWebhookRecord, "webhooks">>>;
+        enqueueDelivery: (input: EnqueueDeliveryInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<EventingDeliveryRecord>>;
+        recordDeliveryAttempt: (input: RecordDeliveryAttemptInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<EventingDeliveryRecord>>;
+        updateDeliveryStatus: (input: UpdateDeliveryStatusInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<EventingDeliveryRecord>>;
+    };
+    beliefs: {
+        create(input: BeliefsCompatCreateInput): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>>;
+        get(nodeId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>>;
+        refine(nodeId: string, textOrInput: string | {
+            text: string;
+            rationale?: string;
+        }, rationale?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>>;
+        updateConfidence(nodeId: string, input: BeliefsCompatUpdateConfidenceInput): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        modulateConfidence(nodeId: string, input: BeliefsCompatUpdateConfidenceInput): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updateStatus(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            status: "active" | "superseded" | "archived";
+            reason?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updateRationale(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            rationale?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        linkBeliefs(input: Parameters<(input: {
+            fromNodeId: string;
+            toNodeId: string;
+            edgeType: string;
+            weight?: number;
+            context?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        unlinkEvidence(input: Parameters<(input: {
+            beliefNodeId?: string;
+            beliefId?: string;
+            insightId?: string;
+            evidenceId?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updateCriticality(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            criticality: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        batchUpdateCriticality(input: Parameters<(input: {
+            updates: {
+                [x: string]: unknown;
+            }[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        reassignTopic(input: Parameters<(input: {
+            beliefNodeIds?: string[];
+            beliefIds?: string[];
+            targetTopicId: string;
+            reason?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        fork(nodeId: string, input: BeliefsCompatForkInput): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>>;
+        archive(nodeId: string, input?: string | {
+            reason?: string;
+            rationale?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(args: {
+            topicId?: string;
+            worktreeId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            beliefs?: ({
+                [x: string]: unknown;
+            } & {
+                id?: string;
+                beliefId?: string;
+                nodeId?: string;
+            })[];
+        }>>;
+        search: (args: {
+            query: string;
+            topicId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+        }) => Promise<{
+            results: Record<string, unknown>[];
+        }>;
+        lineage(nodeId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            beliefId?: string;
+            lineage?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        confidenceHistory(nodeId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        opinionHistory: (nodeId: string) => Promise<OpinionHistoryEntry[]>;
+        createContract(nodeId: string, input: Parameters<(id: string, input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        bisect(nodeId: string, input: Parameters<(id: string, input: {
+            expectedDirection: "overconfident" | "underconfident";
+            timeRange?: {
+                start: number;
+                end: number;
+            };
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+    };
+    webhooks: {
+        create(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(query?: Parameters<(query?: {
+            topicId?: string;
+        }) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            webhooks?: {
+                [x: string]: unknown;
+            }[];
+        }>>>[0]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            webhooks?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        get(id: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        update(id: string, input: Parameters<(id: string, input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        delete(id: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        test(id: string, input?: Parameters<(id: string, input?: {
+            topicId?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        deliveries(id: string, query?: Parameters<(id: string, query?: {
+            limit?: number;
+        }) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        health(id: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+    };
+    edges: {
+        create(args: FunctionSurfaceInput & {
+            from?: unknown;
+            to?: unknown;
+            sourceId?: string;
+            targetId?: string;
+            edgeType: string;
+            topicId?: string;
+            confidence?: number;
+            weight?: number;
+            context?: string;
+            reasoning?: string;
+        }, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        createEdge(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        update(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        updateEdge(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        remove(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        removeEdge(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        removeBetween(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        removeEdgesBetween(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        batchCreate(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        batchCreateEdges(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        delete(input: Parameters<(input: {
+            edgeIds: string[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(args: {
+            sourceId: string;
+            edgeType?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        }>>;
+        traverse(args: {
+            startNode: string;
+            direction?: string;
+            maxDepth?: number;
+            topicId?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+    };
+    evidence: {
+        create(args: {
+            text?: string;
+            canonicalText?: string;
+            topicId?: string;
+            source?: string;
+            sourceUrl?: string;
+            targetId?: string;
+            weight?: number;
+            metadata?: JsonObject;
+            title?: string;
+            content?: string;
+            contentType?: string;
+            kind?: string;
+            supports?: {
+                nodeId: string;
+                weight: number;
+                reasoning?: string;
+            };
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+        }>>;
+        add: (args: {
+            text?: string;
+            canonicalText?: string;
+            topicId?: string;
+            source?: string;
+            sourceUrl?: string;
+            targetId?: string;
+            weight?: number;
+            metadata?: JsonObject;
+            title?: string;
+            content?: string;
+            contentType?: string;
+            kind?: string;
+            rationale?: string;
+            supports?: {
+                nodeId: string;
+                weight: number;
+                reasoning?: string;
+            };
+        }) => Promise<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+        }>;
+        get(evidenceId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(args: {
+            topicId?: string;
+            targetId?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        }>>;
+        search(args: {
+            q?: string;
+            query?: string;
+            topicId?: string;
+            targetId?: string;
+            methodology?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        }>>;
+        link(args: {
+            evidenceId: string;
+            targetId?: string;
+            beliefId?: string;
+            questionId?: string;
+            targetType?: "belief" | "question" | string;
+            weight?: number;
+            rationale?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            edgeId?: string;
+        }>>;
+        linkToBelief(args: {
+            evidenceId: string;
+            beliefId: string;
+            weight: number;
+            rationale?: string;
+        }): Promise<{
+            beliefId: string;
+            edgeId?: string;
+        }>;
+        classifyEvidence(beliefId: string, evidenceId: string, config?: Parameters<(beliefId: string, evidenceId: string, classificationConfig?: EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<ClassifyEvidenceResult>>>[2], idempotencyKey?: string): Promise<GatewayDataEnvelope<ClassifyEvidenceResult>>;
+        classifyEvidenceBatch(beliefId: string, evidence: Parameters<(beliefId: string, evidence: ClassifyEvidenceBatchItem[], classificationConfig?: EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<ClassifyEvidenceBatchResult>>>[1], config?: Parameters<(beliefId: string, evidence: ClassifyEvidenceBatchItem[], classificationConfig?: EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<ClassifyEvidenceBatchResult>>>[2], idempotencyKey?: string): Promise<GatewayDataEnvelope<ClassifyEvidenceBatchResult>>;
+        updateStatus(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        update(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        flagIncorrect(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        remove(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updateVerificationStatus(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+    };
+    sources: {
+        upsert(input: Parameters<(spec: UpsertSourceSpec, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformSourceRecord>>>[0], idempotencyKey?: Parameters<(spec: UpsertSourceSpec, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformSourceRecord>>>[1]): Promise<GatewayDataEnvelope<PlatformSourceRecord>>;
+        get(sourceId: string): Promise<GatewayDataEnvelope<PlatformSourceRecord>>;
+    };
+    questions: {
+        create(args: {
+            text: string;
+            topicId?: string;
+            priority?: string;
+            linkedBeliefId?: string;
+            metadata?: JsonObject;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        get(questionId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        refine(questionId: string, text: string, refinementReason?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(args: {
+            topicId?: string;
+            status?: string;
+            priority?: string;
+            worktreeId?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            questions?: Array<{
+                [x: string]: unknown;
+            } & {
+                priority?: string;
+            }>;
+        }>>;
+        updateStatus(questionId: string, status: string, rationale?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        batchCreate(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        add(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updatePriority(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        advanceToConviction(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updateConviction(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        finalizeConviction(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        update(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        delete(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        answer(questionId: string, input: {
+            text: string;
+            confidence?: string;
+            evidenceIds?: string[];
+            rationale?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        archive(questionId: string, reason?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        linkEvidence(args: {
+            evidenceId: string;
+            questionId: string;
+            relevance?: number;
+            weight?: number;
+            rationale?: string;
+        }): Promise<{
+            questionId: string;
+            relevance: number | undefined;
+            edgeId?: string;
+        }>;
+        getHighPriority(args: {
+            topicId?: string;
+            limit?: number;
+            includeAnswered?: boolean;
+        }): Promise<{
+            questions: ({
+                priority?: string;
+            } & Record<string, unknown>)[];
+        }>;
+        findMissing(args: {
+            topicId?: string;
+            minConfidence?: number;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    graph: {
+        nodes: {
+            list: (query: ListNodesInput) => Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+            get(input: string | Parameters<(query: GetNodeInput) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            create(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+            createEpistemicNode(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+            update(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+            updateEpistemicNode(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+            batchCreate(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+            batchCreateEpistemicNodes(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+            listByTopicAndType(input: {
+                topicId?: string;
+                projectId?: string;
+                nodeType?: string;
+                nodeTypes?: string[];
+                query?: string;
+                sourceText?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+            countByTopicAndType(input: {
+                topicId?: string;
+                projectId?: string;
+                nodeType?: string;
+                nodeTypes?: string[];
+                query?: string;
+                limit?: number;
+            }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+            supersede(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+            verify(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+            archive(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+            hardDelete: (input: HardDeleteNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+        createEdge: (input: CreateEdgeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphEdge>>;
+        neighborhood(args: Parameters<(query: NeighborhoodInput) => Promise<PlatformGatewaySuccess<GraphNeighborhoodResponse>>>[0]): Promise<GatewayDataEnvelope<GraphNeighborhoodResponse>>;
+        queryLineage: (nodeId: string, depth?: number) => Promise<{
+            chain: {
+                nodeId: {};
+                relation: string;
+            }[];
+            forkTree: {
+                nodeId: string;
+                parentCount: number;
+                childCount: number;
+                children: never[];
+            };
+            depth: number;
+            beliefId: string | undefined;
+            lineage: {
+                [x: string]: unknown;
+            }[];
+        }>;
+        getConfidenceHistory: (nodeId: string) => Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        getOpinionHistory: (nodeId: string) => Promise<OpinionHistoryEntry[]>;
+        getAuditTrail: (nodeId: string, limit?: number) => Promise<{
+            entries: {
+                action: string;
+                actor: string;
+                timestamp: number;
+                rationale: string;
+                before: string | number | boolean | JsonObject | JsonArray | null;
+                after: string | number | boolean | JsonObject | JsonArray | null;
+            }[];
+        }>;
+        traverse(args: {
+            startNode: string;
+            direction?: string;
+            maxDepth?: number;
+            topicId?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        analyze(args: {
+            topicId?: string;
+            limit?: number;
+            metric?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        bias(args: {
+            topicId?: string;
+            threshold?: number;
+            limit?: number;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        gaps(args: {
+            topicId?: string;
+            minConfidence?: number;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        falsify(args: {
+            topicId?: string;
+            beliefId?: string;
+            beliefIds?: string[];
+            minConfidence?: number;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        traceEntityImpact(args: {
+            nodeId: string;
+            topicId?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        searchBeliefs: (args: {
+            query: string;
+            topicId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+        }) => Promise<{
+            results: Record<string, unknown>[];
+        }>;
+        findContradictions: (args: {
+            topicId?: string;
+            nodeId?: string;
+            status?: string;
+        }) => Promise<{
+            contradictions: {
+                beliefA: string;
+                beliefB: string;
+                description: string;
+                severity: string;
+                status: string;
+                defeatType: string;
+            }[];
+        }>;
+        bisectConfidence: (nodeId: string, args: {
+            expectedDirection: "overconfident" | "underconfident";
+        }) => Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        listBeliefs: (args: {
+            topicId?: string;
+            worktreeId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+            cursor?: string;
+        }) => Promise<({
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        })[]>;
+        detectConfirmationBias(topicId: string, threshold?: number): Promise<{
+            topicId: string;
+            threshold: number;
+            success: true;
+            data: Record<string, unknown>;
+            correlationId: string;
+            policyTraceId: string | null;
+            idempotentReplay: boolean;
+        }>;
+        getStructureAnalysis(topicId: string): Promise<{
+            topicId: string;
+            success: true;
+            data: Record<string, unknown>;
+            correlationId: string;
+            policyTraceId: string | null;
+            idempotentReplay: boolean;
+        }>;
+        getFalsificationQuestions(topicId: string, beliefIds?: string[]): Promise<{
+            topicId: string;
+            questions: unknown;
+        }>;
+    };
+    themes: {
+        listByTopic(input: {
+            topicId?: string;
+            projectId?: string;
+            query?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    graphSearch: {
+        keywordSearchNodes(input: {
+            topicId?: string;
+            projectId?: string;
+            query?: string;
+            sourceText?: string;
+            nodeType?: string;
+            nodeTypes?: string[];
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    classifiers: {
+        listBeliefCandidates(input: {
+            topicId?: string;
+            projectId?: string;
+            classifierKey?: string;
+            query?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    archetypes: {
+        getJudgmentSignature(input: {
+            topicId?: string;
+            projectId?: string;
+            principalId?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    judgments: {
+        create: (input: RecordJudgmentInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+        record: (input: RecordJudgmentInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+        list: (query: ListJudgmentsInput) => Promise<PlatformGatewaySuccess<ListJudgmentsResponse>>;
+        get: (judgmentId: string) => Promise<PlatformGatewaySuccess<GetJudgmentResponse>>;
+        recordOutcome: (judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+        updateOutcome: (judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+        readiness(topicId: string): Promise<PlatformGatewaySuccess<JudgmentReadinessResponse>>;
+        calibration(topicId: string): Promise<PlatformGatewaySuccess<JudgmentCalibrationResponse>>;
+        pendingOutcomeReview(topicId: string): Promise<PlatformGatewaySuccess<ListResult<PendingJudgmentOutcomeRecord, "reviews">>>;
+        transitionAuditIntegrity(args: {
+            topicId?: string;
+            judgmentId?: string;
+            includePassing?: boolean;
+        }): Promise<PlatformGatewaySuccess<JudgmentTransitionAuditIntegrityResponse>>;
+    };
+    decisions: {
+        create: (input: RecordJudgmentInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+        record: (input: RecordJudgmentInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+        list: (query: ListJudgmentsInput) => Promise<PlatformGatewaySuccess<ListJudgmentsResponse>>;
+        get: (judgmentId: string) => Promise<PlatformGatewaySuccess<GetJudgmentResponse>>;
+        recordOutcome: (judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+        lessons(decisionId: string, input: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        archive(decisionId: string, input?: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        readiness(topicId: string): Promise<PlatformGatewaySuccess<JudgmentReadinessResponse>>;
+        calibration(topicId: string): Promise<PlatformGatewaySuccess<JudgmentCalibrationResponse>>;
+        pendingOutcomeReview(topicId: string): Promise<PlatformGatewaySuccess<ListResult<PendingJudgmentOutcomeRecord, "reviews">>>;
+    };
+    worktrees: {
+        createBranch: (input: {
+            name: string;
+            topicId?: string;
+            description?: string;
+            metadata?: JsonObject;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowBranchRecord>>;
+        createLens: (input: {
+            name: string;
+            workspaceId?: string;
+            topicId?: string;
+            description?: string;
+            perspectiveType: WorkflowLensPerspectiveType;
+            promptTemplates?: LensPromptTemplateReference[];
+            workflowTemplates?: LensWorkflowTemplate[];
+            taskTemplates?: LensTaskTemplate[];
+            filterCriteria?: JsonObject;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowLensRecord>>;
+        listLenses: (query: {
+            workspaceId?: string;
+            topicId?: string;
+            status
+            /**
+             * Optional pack key for auto-install convenience.
+             * When set, the SDK will call `packs.install()` on first use
+             * to ensure the pack is available in the workspace.
+             */
+            ? /**
+             * Optional pack key for auto-install convenience.
+             * When set, the SDK will call `packs.install()` on first use
+             * to ensure the pack is available in the workspace.
+             */: WorkflowLensStatus;
+            perspectiveType?: WorkflowLensPerspectiveType;
+        } & TopicIdentifierInput) => Promise<PlatformGatewaySuccess<ListResult<WorkflowLensRecord, "lenses">>>;
+        applyLensToTopic: (input: {
+            lensId: string;
+            topicId?: string;
+            metadata?: JsonObject;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>;
+        removeLensFromTopic: (input: {
+            lensId: string;
+            topicId?: string;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>;
+        create(input: AddWorktreeInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        add(input: AddWorktreeInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        list(query: Parameters<(query: {
+            topicId?: string;
+            branchId?: string;
+            status?: WorkflowWorktreeStatus;
+            groupBy?: "campaign" | "lane" | "flat";
+            lane?: string;
+            campaign?: number;
+            limit?: number;
+        } & TopicIdentifierInput) => Promise<PlatformGatewaySuccess<ListResult<WorkflowWorktreeRecord, "worktrees">>>>[0]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            worktrees?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        listByTopic(query: Parameters<(query: {
+            topicId?: string;
+            branchId?: string;
+            status?: WorkflowWorktreeStatus;
+            groupBy?: "campaign" | "lane" | "flat";
+            lane?: string;
+            campaign?: number;
+            limit?: number;
+        } & TopicIdentifierInput) => Promise<PlatformGatewaySuccess<ListResult<WorkflowWorktreeRecord, "worktrees">>>>[0]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            worktrees?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        findByPairedSprint(input: {
+            sprintId: string;
+            topicId?: string;
+            projectId?: string;
+            limit?: number;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        activate(worktreeId: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        updateMetadata(input: FunctionSurfaceInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        update(input: FunctionSurfaceInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        updateTargets(input: Parameters<(input: UpdateWorktreeTargetsInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>>[0]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        listAll: (query?: {
+            status?: WorkflowWorktreeStatus;
+            groupBy?: "campaign" | "lane" | "flat";
+            lane?: string;
+            campaign?: number;
+            limit?: number;
+        }) => Promise<PlatformGatewaySuccess<ListWorktreesResponse>>;
+        merge(worktreeId: string, input: MergeInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        push: (worktreeId: string, input: {
+            targetContext: string;
+            beliefIds?: string[];
+            metadata?: JsonObject;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PushWorktreeResponse>>;
+        openPullRequest: (worktreeId: string, input: {
+            summary: string;
+            reviewers?: string[];
+            status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<OpenPullRequestResponse>>;
+        pipelineSnapshot(topicId: string): FunctionSurfaceResult<unknown>;
+        complete: (input: {
+            worktreeId: string;
+            keyFindings?: string[];
+            decisionsReached?: string[];
+            nextSteps?: string[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        advancePhase(worktreeId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        setPhase(worktreeId: string, phase: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        patchState: (input: {
+            worktreeId: string;
+            patch: {
+                [x: string]: unknown;
+            };
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        bulkCreate: (input: {
+            worktrees: unknown[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+    };
+    context: {
+        listTopics(query?: Parameters<(query?: TopicListInput) => Promise<PlatformGatewaySuccess<TopicListResponse>>>[0]): Promise<PlatformGatewaySuccess<TopicListResponse>>;
+        compile: (topicIdOrInput?: string | CompileContextInput, input?: CompileContextInput) => Promise<PlatformGatewaySuccess<PublicCompiledContext>>;
+        recordScopeLearning: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        discover(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        analyzeTopicDensity: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        applyAutoBranching: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        seedBeliefLattice: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        getLatticeCoverage: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        matchEntityType(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        discoverEntityConnections(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        triggerBeliefReview(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    tasks: {
+        create(input: CreateTaskInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        complete(taskId: string, input: CompleteTaskInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        update(taskId: string, input: UpdateTaskInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        list(input: FunctionSurfaceInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            tasks?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        listByTopic(input: FunctionSurfaceInput & {
+            topicId?: string;
+        }): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            tasks?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        listByWorktree(input: FunctionSurfaceInput & {
+            worktreeId: string;
+        }): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            tasks?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        linkChat(taskId: string, input: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    topics: {
+        list(input?: Parameters<(query?: TopicListInput) => Promise<PlatformGatewaySuccess<TopicListResponse>>>[0]): Promise<PlatformGatewaySuccess<TopicListResponse>>;
+        get: (topicId: string) => Promise<PlatformGatewaySuccess<TopicRecord>>;
+        create(input: Parameters<(input: TopicCreateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<TopicRecord>>>[0]): Promise<GatewayDataEnvelope<unknown>>;
+        update(topicId: string, input: Parameters<(topicId: string, input: TopicUpdateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<TopicRecord>>>[1]): Promise<PlatformGatewaySuccess<TopicRecord>>;
+        tree(topicId: string, query?: Parameters<(topicId: string, query?: TopicTreeQuery) => Promise<PlatformGatewaySuccess<TopicTreeResponse>>>[1]): Promise<PlatformGatewaySuccess<TopicTreeResponse>>;
+        getTree(input: {
+            rootId: string;
+            maxDepth?: number;
+        }): Promise<PlatformGatewaySuccess<TopicTreeResponse>>;
+        coverage(topicId: string, query?: Parameters<(topicId: string, query?: TopicCoverageQuery) => Promise<PlatformGatewaySuccess<TopicCoverageResponse>>>[1]): Promise<PlatformGatewaySuccess<TopicCoverageResponse>>;
+        remove: (topicId: string, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        bulkCreate: (input: TopicBulkCreateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        materializeGraph(input?: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        materializeTopicGraph(input?: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        graphSpine(input?: FunctionSurfaceInput): Promise<GatewayDataEnvelope<unknown>>;
+        getTopicGraphSpine(input?: FunctionSurfaceInput): Promise<GatewayDataEnvelope<unknown>>;
+    };
+    answers: {
+        create(input: FunctionSurfaceInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        get(input: FunctionSurfaceInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    };
+    contradictions: {
+        flag(args: {
+            beliefA: string;
+            beliefB: string;
+            description: string;
+            topicId?: string;
+            severity?: string;
+            defeatType?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(args: {
+            topicId?: string;
+            status?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            contradictions?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        get(contradictionId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        find: (args: {
+            topicId?: string;
+            nodeId?: string;
+            status?: string;
+        }) => Promise<{
+            contradictions: {
+                beliefA: string;
+                beliefB: string;
+                description: string;
+                severity: string;
+                status: string;
+                defeatType: string;
+            }[];
+        }>;
+    };
+    ontologies: {
+        list(input?: {
+            tenantId?: string;
+            tier?: string;
+            status?: string;
+        }): Promise<GatewayDataEnvelope<{
+            ontologies: unknown[];
+            total: number;
+            items: unknown[];
+            definitions: unknown[];
+        }>>;
+        get(ontologyId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        bind(input: Parameters<(input: OntologyBindingInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: Parameters<(input: OntologyBindingInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        match(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        create(input: FunctionSurfaceInput): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        update(input: FunctionSurfaceInput): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        archive(input: FunctionSurfaceInput): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        createVersion(input: FunctionSurfaceInput): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        publishVersion(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        publishOntologyVersion(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        deprecateVersion(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        deprecateOntologyVersion(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        resolveEffective(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        resolveEffectiveOntology(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        raw: {
+            list(filters?: GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<{
+                ontologies: unknown[];
+                total: number;
+                items: unknown[];
+                definitions: unknown[];
+            }>>;
+            get(id: string): Promise<PlatformGatewaySuccess<unknown>>;
+            bind(input: OntologyBindingInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            createDefinition(input: OntologyDefinitionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateDefinition(id: string, input: OntologyDefinitionUpdateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            archiveDefinition(id: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listVersions(ontologyId: string, filters?: GatewayScope & {
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<unknown, "versions">>>;
+            createVersion(ontologyId: string, input: OntologyVersionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            publishVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deprecateVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTopics(ontologyId: string): Promise<PlatformGatewaySuccess<ListResult<any, "topics">>>;
+        } & {
+            listDefinitions: (filters?: GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }) => Promise<PlatformGatewaySuccess<{
+                ontologies: unknown[];
+                total: number;
+                items: unknown[];
+                definitions: unknown[];
+            }>>;
+            getDefinition: (id: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            listTopicsByOntology: (ontologyId: string) => Promise<PlatformGatewaySuccess<ListResult<any, "topics">>>;
+        };
+    };
+    coordination: {
+        registerSession: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        heartbeatSession: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        endSession: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        listActiveSessions: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        sendAgentMessage: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        broadcastMessage: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        getInbox: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        getAgentInbox: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        claimFiles: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+    };
+    policy: {
+        checkPermission(input: FunctionSurfaceInput): Promise<PlatformGatewaySuccess<PermissionDecision>>;
+        listAccessibleTopics(input?: Parameters<(query?: GatewayScope & {
+            permission?: PermissionKind;
+            includeShared?: boolean;
+            principal?: string;
+            principalId?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                permission: PermissionKind;
+                topics: {
+                    [key: string]: unknown;
+                    topicId?: string;
+                    name?: string;
+                    type?: string;
+                    isOwner?: boolean;
+                }[];
+                total: number;
+                deniedTopics: {
+                    topicId: string;
+                    reasonCode: string;
+                }[];
+            };
+            success: true;
+            correlationId: string;
+            policyTraceId: string | null;
+            idempotentReplay: boolean;
+        }>>[0]): Promise<{
+            data: {
+                permission: PermissionKind;
+                topics: {
+                    [key: string]: unknown;
+                    topicId?: string;
+                    name?: string;
+                    type?: string;
+                    isOwner?: boolean;
+                }[];
+                total: number;
+                deniedTopics: {
+                    topicId: string;
+                    reasonCode: string;
+                }[];
+            };
+            success: true;
+            correlationId: string;
+            policyTraceId: string | null;
+            idempotentReplay: boolean;
+        }>;
+        filterByPermission(input: FunctionSurfaceInput): Promise<{
+            success: true;
+            data: {
+                permission: PermissionKind;
+                allowedTopicIds: string[];
+                deniedTopics: Array<{
+                    topicId: string;
+                    reasonCode: string;
+                }>;
+                count: number;
+            };
+        }>;
+        manageWritePolicy(input: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+        raw: {
+            listDecisions(query?: GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "decisions">>>;
+            grant(input: GatewayScope & {
+                topicId: string;
+                permission: PermissionKind;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+                expiresAt?: number;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revoke(input: GatewayScope & {
+                topicId: string;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listWritePolicies(query?: GatewayScope & {
+                topicId?: string;
+                role?: string;
+                toolCategory?: string;
+                enabled?: boolean;
+            }): Promise<{
+                data: {
+                    policies: WritePolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createWritePolicy(input: WritePolicyCreateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    created: boolean;
+                    policy: WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateWritePolicy(id: string, input: WritePolicyUpdateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    updated: boolean;
+                    policy: WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteWritePolicy(id: string, scope?: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                id?: string;
+                deleted?: boolean;
+            }>>;
+            listRolePolicies(query?: GatewayScope): Promise<{
+                data: {
+                    policies: TenantPolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createRolePolicy(input: GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateRolePolicy(id: string, input: GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteRolePolicy(id: string, scope?: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            checkPermission(query: GatewayScope & {
+                topicId?: string;
+                permission?: PermissionKind;
+                principal?: string;
+                principalId?: string;
+                beliefClusterId?: string;
+            }): Promise<PlatformGatewaySuccess<PermissionDecision>>;
+            listAccessibleTopics(query?: GatewayScope & {
+                permission?: PermissionKind;
+                includeShared?: boolean;
+                principal?: string;
+                principalId?: string;
+                limit?: number;
+            }): Promise<{
+                data: {
+                    permission: PermissionKind;
+                    topics: {
+                        [key: string]: unknown;
+                        topicId?: string;
+                        name?: string;
+                        type?: string;
+                        isOwner?: boolean;
+                    }[];
+                    total: number;
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            filterByPermission(input: GatewayScope & {
+                topicIds?: string[];
+                permission?: PermissionKind;
+                principal?: string;
+                principalId?: string;
+            }): Promise<{
+                success: true;
+                data: {
+                    permission: PermissionKind;
+                    allowedTopicIds: string[];
+                    deniedTopics: Array<{
+                        topicId: string;
+                        reasonCode: string;
+                    }>;
+                    count: number;
+                };
+            }>;
+        };
+    };
+    observations: {
+        ingest: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        ingestObservation: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        getContext: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        getObservationContext: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+    };
+    coding: {
+        getCodeContext: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        getChangeHistory: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        recordAttempt: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+        getFailureLog: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+    };
+    contracts: {
+        create(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        createEpistemicContract(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        list(input?: {
+            beliefNodeId?: string;
+            contractId?: string;
+            status?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        evaluate(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        evaluateContract(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        getStatus(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        getContractStatus(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    bootstrap: {
+        generateSessionHandoff: (input?: FunctionSurfaceInput, idempotencyKey?: string) => FunctionSurfaceResult<unknown>;
+    };
+    embeddings: {
+        getByNodeIds(input: GetEmbeddingsByNodeIdsInput): Promise<PlatformGatewaySuccess<ListResult<EmbeddingRecord, "embeddings">>>;
+        listMissingForTopic(input: ListMissingEmbeddingsInput): Promise<PlatformGatewaySuccess<ListResult<MissingEmbeddingCandidate, "nodes">>>;
+        vectorSearchByTopic(input: VectorSearchByTopicInput): Promise<PlatformGatewaySuccess<ListResult<VectorSearchMatch, "results">>>;
+        markEmbeddingBackfillQueued(input: MarkEmbeddingBackfillQueuedInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            queued: number;
+            topicId: string;
+            workspaceId: string;
+            nodeIds: string[];
+        }>>;
+    };
+    graphAnalysis: {
+        listGraphIntelligenceQueries(input?: ListGraphIntelligenceQueriesInput): Promise<PlatformGatewaySuccess<GraphIntelligenceQueryCatalogResponse>>;
+        runGraphIntelligenceQuery(input: RunGraphIntelligenceQueryInput): Promise<PlatformGatewaySuccess<GraphIntelligenceQueryRunResponse>>;
+        saveAnalysis(input: SaveGraphAnalysisInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphAnalysisRecord>>;
+        listAnalyses(input: ListGraphAnalysesInput): Promise<PlatformGatewaySuccess<ListResult<any, "analyses">>>;
+        getLatestAnalysis(input: GetLatestGraphAnalysisInput): Promise<PlatformGatewaySuccess<GraphAnalysisRecord>>;
+        saveSuggestions(input: SaveGraphSuggestionsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphAnalysisSuggestionsResponse>>;
+        updateSuggestionStatus(input: UpdateGraphSuggestionStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphAnalysisSuggestion>>;
+        listSuggestions(input: ListGraphSuggestionsInput): Promise<PlatformGatewaySuccess<ListResult<any, "suggestions">>>;
+        listGraphChanges(input: ListGraphChangesInput): Promise<PlatformGatewaySuccess<ListResult<any, "changes">>>;
+        computeOrRequestAnalysis(input: ComputeOrRequestGraphAnalysisInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphAnalysisRecord>>;
+    };
+    graphRecommendations: {
+        listForTopic(input: GraphRecommendationListInput): Promise<PlatformGatewaySuccess<ListResult<any, "recommendations">>>;
+        getRecommendation(recommendationId: string): Promise<PlatformGatewaySuccess<GraphRecommendationRecord>>;
+        markRecommendationStatus(input: MarkGraphRecommendationStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphRecommendationRecord>>;
+    };
+    orgGraphSearch: {
+        search(input: OrgGraphSearchInput): Promise<PlatformGatewaySuccess<OrgGraphSearchResponse>>;
+        getNode(input: GetOrgGraphNodeInput): Promise<PlatformGatewaySuccess<OrgGraphSearchResult>>;
+        listByProvenance(input: ListOrgGraphByProvenanceInput): Promise<PlatformGatewaySuccess<OrgGraphSearchResponse>>;
+        listPublishedFromWorkspace(input: ListPublishedFromWorkspaceInput): Promise<PlatformGatewaySuccess<OrgGraphSearchResponse>>;
+    };
+    ontologyLinks: {
+        resolveThemeSource(input: JsonObject): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        createLink(input: OntologyLinkWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<OntologyLinkRecord>>;
+        upsertLink(input: OntologyLinkWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<OntologyLinkRecord>>;
+        listLinksForNode(input: ListOntologyLinksForNodeInput): Promise<PlatformGatewaySuccess<ListResult<OntologyLinkRecord, "links">>>;
+        updateLinkStatus(input: UpdateOntologyLinkStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<OntologyLinkRecord>>;
+    };
+    graphStateClassifier: {
+        classifyNode(input: ClassifyNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphStateClassification>>;
+        classifyTopic(input: ClassifyTopicInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ListResult<GraphStateClassification, "classifications">>>;
+        listClassifications(input: ListGraphStateClassificationsInput): Promise<PlatformGatewaySuccess<ListResult<GraphStateClassification, "classifications">>>;
+        recordClassification(input: RecordGraphStateClassificationInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphStateClassification>>;
+    };
+    modelRuntime: {
+        listModels(input: ModelRuntimeScope): Promise<PlatformGatewaySuccess<ListResult<ModelRegistryRecord, "models">>>;
+        getModel(input: ModelRuntimeScope & {
+            modelId: string;
+        }): Promise<PlatformGatewaySuccess<ModelRegistryRecord>>;
+        listFunctionSlots(input: ModelRuntimeScope & {
+            functionName?: string;
+        }): Promise<PlatformGatewaySuccess<ListResult<ModelFunctionSlot, "slots">>>;
+        resolveSlot(input: ResolveModelSlotInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ModelFunctionSlot>>;
+        updateSlotConfig(input: UpdateModelSlotConfigInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ModelFunctionSlot>>;
+    };
+    jobs: {
+        enqueue(input: EnqueueJobInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRecord>>;
+        list(input: JobsScope): Promise<PlatformGatewaySuccess<ListResult<JobRecord, "jobs">>>;
+        claim(input: ClaimJobInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRecord>>;
+        updateStatus(input: UpdateJobStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRecord>>;
+        retry(input: RetryJobInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRecord>>;
+        recordRunStart(input: RecordJobRunStartInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRunRecord>>;
+        recordRunFinish(input: RecordJobRunFinishInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRunRecord>>;
+    };
+    telemetry: {
+        logSystemEvent(input: LogSystemEventInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            eventId?: string;
+            recorded: boolean;
+        }>>;
+        logToolCallsBatch(input: LogToolCallsBatchInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            recorded: number;
+        }>>;
+        recordEpistemicAudit(input: RecordEpistemicAuditInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            auditId?: string;
+            recorded: boolean;
+        }>>;
+        recordPolicyDecision(input: RecordTelemetryPolicyDecisionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            decisionId?: string;
+            recorded: boolean;
+        }>>;
+        startRun(input: StartTelemetryRunInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TelemetryRunRecord>>;
+        finishRun(input: FinishTelemetryRunInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TelemetryRunRecord>>;
+        listRuns(input: TelemetryScope): Promise<PlatformGatewaySuccess<ListResult<TelemetryRunRecord, "runs">>>;
+    };
+    publication: {
+        create(input: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        update(publicationId: string, input: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        list(input?: JsonObject): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        getByTopic(input: string | {
+            topicId: string;
+            workspaceId?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        publish(publicationId: string, input?: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        unpublish(publicationId: string, input?: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        remove(publicationId: string, input?: JsonObject): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    contentPublication: {
+        create(input: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        update(publicationId: string, input: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        list(input?: JsonObject): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        getByTopic(input: string | {
+            topicId: string;
+            workspaceId?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        publish(publicationId: string, input?: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        unpublish(publicationId: string, input?: JsonObject, idempotencyKey?: string): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        remove(publicationId: string, input?: JsonObject): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    tools: {
+        listCatalog: (input: ToolRegistryQuery) => Promise<PlatformGatewaySuccess<ListResult<ToolCatalogEntry, "tools">>>;
+        listExecutable: (input: ToolRegistryQuery) => Promise<PlatformGatewaySuccess<ListResult<ToolCatalogEntry, "tools">>>;
+        listEffectiveTools: (input: EffectiveToolsQuery) => Promise<PlatformGatewaySuccess<ListResult<ToolCatalogEntry, "tools">>>;
+        upsertCoreTools: (input: UpsertCoreToolsInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<ListResult<ToolCatalogEntry, "tools">>>;
+        setPackToolsStatus: (input: SetPackToolsStatusInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<ListResult<ToolCatalogEntry, "tools">>>;
+        createAcl: (input: CreateToolAclInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<ToolAclRecord>>;
+        deleteAcl: (input: DeleteToolAclInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            aclId: string;
+            deleted: boolean;
+        }>>;
+        registerCustomTool: (input: RegisterCustomToolInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<ToolCatalogEntry>>;
+        register: typeof registerCustomTool;
+        unregister: typeof unregisterCustomTool;
+        list: typeof listRegisteredCustomTools;
+        clear: typeof clearRegisteredCustomTools;
+        invoke(name: string, input?: CustomToolInput): Promise<unknown>;
+        namespace: (namespace: string) => CustomToolNamespace;
+    };
+    packs: {
+        /**
+         * Ensure the configured packKey is installed.
+         * 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: () => Promise<void>;
+        /**
+         * Check if the configured pack has been installed in this session.
+         */
+        readonly isInstalled: boolean;
+        listCatalog: () => Promise<PlatformGatewaySuccess<ListResult<any, "catalog">>>;
+        catalog: () => Promise<PlatformGatewaySuccess<ListResult<any, "catalog">>>;
+        listStates: (query?: GatewayScope) => Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+        states: (query?: GatewayScope) => Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+        install: (input: PackInstallInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+        enable: (input: PackEnableInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+        disable: (input: PackDisableInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    nodes: {
+        list: (query: ListNodesInput) => Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+        get(input: string | Parameters<(query: GetNodeInput) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+        create(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        createEpistemicNode(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        update(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        updateEpistemicNode(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        batchCreate(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        batchCreateEpistemicNodes(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        listByTopicAndType(input: {
+            topicId?: string;
+            projectId?: string;
+            nodeType?: string;
+            nodeTypes?: string[];
+            query?: string;
+            sourceText?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        countByTopicAndType(input: {
+            topicId?: string;
+            projectId?: string;
+            nodeType?: string;
+            nodeTypes?: string[];
+            query?: string;
+            limit?: number;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        supersede(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        verify(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        archive(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<GatewayDataEnvelope<unknown>>;
+        hardDelete: (input: HardDeleteNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    };
+    identity: {
+        access: {
+            normalizePrincipal: typeof normalizeCanonicalPrincipalIdentity;
+            checkAccess: (input: RequireAccessInput, idempotencyKey?: string) => Promise<AccessCheckResult>;
+            requireAccess: (input: RequireAccessInput, idempotencyKey?: string) => Promise<AccessCheckResult>;
+            canAccess: (input: RequireAccessInput, idempotencyKey?: string) => Promise<boolean>;
+        };
+        evaluatePolicy: (input: PolicyEvaluationInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PolicyDecisionRecord>>;
+        recordPolicyDecision: (input: RecordPolicyDecisionInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PolicyDecisionRecord>>;
+        putSecretReference: (input: PutTenantSecretReferenceInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<TenantSecretReference>>;
+        createPrincipal: (input: 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<PlatformGatewaySuccess<unknown>>;
+        updatePrincipal: (input: 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<PlatformGatewaySuccess<unknown>>;
+        raw: {
+            whoami(): Promise<PlatformGatewaySuccess<{
+                principalId: string;
+                principalType: "human" | "service" | "agent" | "user" | "group" | "external_viewer";
+                tenantId: string | null;
+                workspaceId: string | null;
+                scopes: string[];
+                roles: string[];
+                isPlatformAdmin: boolean;
+                isTenantAdmin: boolean;
+                isWorkspaceAdmin: boolean;
+                authMode: string | undefined;
+                sessionId: string | undefined;
+                delegatedBy: string | undefined;
+                expiresAt: number | undefined;
+            }>>;
+            listPrincipals(query?: GatewayScope & {
+                status?: string;
+                principalType?: string;
+                query?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "principals">>>;
+            createPrincipal(input: 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<PlatformGatewaySuccess<unknown>>;
+            updatePrincipal: (input: 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<PlatformGatewaySuccess<unknown>>;
+            upsertPrincipal: (input: 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<PlatformGatewaySuccess<unknown>>;
+            listKeys(query?: GatewayScope & {
+                principalId?: string;
+                status?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "keys">>>;
+            createKey(input: GatewayScope & {
+                principalId: string;
+                keyId?: string;
+                token?: string;
+                scopes?: string[];
+                environment?: "sandbox" | "production";
+                expiresInDays?: number;
+                rateLimitTier?: "free" | "developer" | "partner";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            rotateKey(keyId: string, input?: {
+                replacementKeyId?: string;
+                replacementToken?: string;
+                replacementExpiresInDays?: number;
+                gracePeriodHours?: number;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deleteKey: (keyId: string, input?: {
+                reason?: string;
+            }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            revokeKey: (keyId: string, input?: {
+                reason?: string;
+            }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            searchClerkUsers(q: string): Promise<PlatformGatewaySuccess<ClerkUserSearchResult[]>>;
+            getTenantConfig(input: TenantIdentityScope): Promise<PlatformGatewaySuccess<TenantIdentityConfigRecord>>;
+            updateTenantConfig(input: UpdateTenantConfigInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TenantIdentityConfigRecord>>;
+            listIntegrations(input: TenantIdentityScope): Promise<PlatformGatewaySuccess<ListResult<TenantIntegrationRecord, "integrations">>>;
+            upsertIntegration(input: UpsertTenantIntegrationInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TenantIntegrationRecord>>;
+            listSecrets(input: TenantIdentityScope): Promise<PlatformGatewaySuccess<ListResult<TenantSecretReference, "secrets">>>;
+            putSecretReference(input: PutTenantSecretReferenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TenantSecretReference>>;
+            evaluatePolicy(input: PolicyEvaluationInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PolicyDecisionRecord>>;
+            recordPolicyDecision(input: RecordPolicyDecisionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PolicyDecisionRecord>>;
+        };
+        whoami(): Promise<PlatformGatewaySuccess<{
+            principalId: string;
+            principalType: "human" | "service" | "agent" | "user" | "group" | "external_viewer";
+            tenantId: string | null;
+            workspaceId: string | null;
+            scopes: string[];
+            roles: string[];
+            isPlatformAdmin: boolean;
+            isTenantAdmin: boolean;
+            isWorkspaceAdmin: boolean;
+            authMode: string | undefined;
+            sessionId: string | undefined;
+            delegatedBy: string | undefined;
+            expiresAt: number | undefined;
+        }> & {
+            principalId: string;
+            principalType: "human" | "service" | "agent" | "user" | "group" | "external_viewer";
+            tenantId: string | null;
+            workspaceId: string | null;
+            scopes: string[];
+            roles: string[];
+            isPlatformAdmin: boolean;
+            isTenantAdmin: boolean;
+            isWorkspaceAdmin: boolean;
+            authMode: string | undefined;
+            sessionId: string | undefined;
+            delegatedBy: string | undefined;
+            expiresAt: number | undefined;
+        }>;
+    };
+    mcp: {
+        bootstrapSession: (input?: McpBootstrapSessionInput) => Promise<McpBootstrapSessionResponse>;
+        checkWritePolicy: (input: McpCheckWritePolicyInput) => Promise<McpCheckWritePolicyResponse>;
+        beginBuildSession: (input: McpBeginBuildSessionInput) => Promise<McpBeginBuildSessionResponse>;
+        evaluateEngineeringContract: (input: McpEvaluateEngineeringContractInput) => Promise<McpContractEvaluationResponse>;
+        evaluateResearchContract: (input: McpEvaluateResearchContractInput) => Promise<McpContractEvaluationResponse>;
+    };
+    auth: {
+        device: {
+            createCode: (input?: DeviceCodeInput) => Promise<DeviceCodeResponse>;
+            pollToken: (deviceCode: string) => Promise<DeviceTokenResponse>;
+        };
+    };
+    custom: CustomToolNamespace;
+    extensions: Record<string, CustomToolNamespace>;
+    raw: {
+        beliefs: {
+            createBelief(input: CreateBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformBeliefRecord>>;
+            refineBelief(beliefId: string, input: RefineBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformBeliefRecord>>;
+            modulateConfidence: (beliefId: string, input: ModulateConfidenceOpinionInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<ModulateConfidenceResponse>>;
+            getOpinionHistory: (beliefId: string) => Promise<OpinionHistoryEntry[]>;
+            getConfidenceHistory: (beliefId: string) => Promise<OpinionHistoryEntry[]>;
+            forkBelief(beliefId: string, input: ForkBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ForkBeliefResponse>>;
+            updateBeliefStatus(input: UpdateBeliefStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            updateBeliefRationale(input: UpdateBeliefRationaleInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            linkBeliefs(input: LinkBeliefsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            unlinkBeliefEvidence(input: UnlinkBeliefEvidenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            updateBeliefCriticality(input: UpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            batchUpdateBeliefCriticality(input: BatchUpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            reassignBeliefsTopic(input: ReassignBeliefsTopicInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+        sources: {
+            upsert(spec: UpsertSourceSpec, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformSourceRecord>>;
+            get(sourceId: string): Promise<PlatformGatewaySuccess<PlatformSourceRecord>>;
+        };
+        evidence: {
+            classifyEvidence(beliefId: string, evidenceId: string, classificationConfig?: EvidenceClassificationRequestConfig, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ClassifyEvidenceResult>>;
+            classifyEvidenceBatch(beliefId: string, evidence: ClassifyEvidenceBatchItem[], classificationConfig?: EvidenceClassificationRequestConfig, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ClassifyEvidenceBatchResult>>;
+        };
+        embeddings: {
+            getByNodeIds(input: GetEmbeddingsByNodeIdsInput): Promise<PlatformGatewaySuccess<ListResult<EmbeddingRecord, "embeddings">>>;
+            listMissingForTopic(input: ListMissingEmbeddingsInput): Promise<PlatformGatewaySuccess<ListResult<MissingEmbeddingCandidate, "nodes">>>;
+            vectorSearchByTopic(input: VectorSearchByTopicInput): Promise<PlatformGatewaySuccess<ListResult<VectorSearchMatch, "results">>>;
+            markEmbeddingBackfillQueued(input: MarkEmbeddingBackfillQueuedInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                queued: number;
+                topicId: string;
+                workspaceId: string;
+                nodeIds: string[];
+            }>>;
+        };
+        eventing: {
+            recordEvent(input: RecordEventInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<EventingRecord>>;
+            listEvents(input: EventingScope): Promise<PlatformGatewaySuccess<ListResult<EventingRecord, "events">>>;
+            listWebhooks(input: EventingScope): Promise<PlatformGatewaySuccess<ListResult<EventingWebhookRecord, "webhooks">>>;
+            enqueueDelivery(input: EnqueueDeliveryInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<EventingDeliveryRecord>>;
+            recordDeliveryAttempt(input: RecordDeliveryAttemptInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<EventingDeliveryRecord>>;
+            updateDeliveryStatus(input: UpdateDeliveryStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<EventingDeliveryRecord>>;
+        };
+        graph: {
+            listNodes(query: ListNodesInput): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+            getNode(query: GetNodeInput): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            createNode(input: CreateNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            updateNode(input: UpdateNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            batchCreateNodes(input: BatchCreateNodesInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            supersedeNode(input: SupersedeNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            verifyNode(input: VerifyNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            hardDeleteNode(input: HardDeleteNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            listEdges(query: ListEdgesInput): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphEdge, "edges">>>;
+            createEdge(input: CreateEdgeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphEdge>>;
+            deleteEdge(query: DeleteEdgeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<DeleteEdgeResponse>>;
+            neighborhood(query: NeighborhoodInput): Promise<PlatformGatewaySuccess<GraphNeighborhoodResponse>>;
+            traverse(query: TraverseInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            analyze(query?: AnalyzeInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            bias(query?: BiasInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            gaps(query: GapsInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            search(query: SearchInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            getPath(query: PathInput): Promise<PlatformGatewaySuccess<GraphPathResponse>>;
+            getAnalytics(query?: AnalyticsInput): Promise<PlatformGatewaySuccess<GraphAnalyticsResponse>>;
+        } & {
+            queryNodes: (query: ListNodesInput) => Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+            queryEdges: (query: ListEdgesInput) => Promise<PlatformGatewaySuccess<ListResult<PlatformGraphEdge, "edges">>>;
+            getNeighborhood: (query: NeighborhoodInput) => Promise<PlatformGatewaySuccess<GraphNeighborhoodResponse>>;
+        };
+        graphAnalysis: {
+            listGraphIntelligenceQueries(input?: ListGraphIntelligenceQueriesInput): Promise<PlatformGatewaySuccess<GraphIntelligenceQueryCatalogResponse>>;
+            runGraphIntelligenceQuery(input: RunGraphIntelligenceQueryInput): Promise<PlatformGatewaySuccess<GraphIntelligenceQueryRunResponse>>;
+            saveAnalysis(input: SaveGraphAnalysisInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphAnalysisRecord>>;
+            listAnalyses(input: ListGraphAnalysesInput): Promise<PlatformGatewaySuccess<ListResult<any, "analyses">>>;
+            getLatestAnalysis(input: GetLatestGraphAnalysisInput): Promise<PlatformGatewaySuccess<GraphAnalysisRecord>>;
+            saveSuggestions(input: SaveGraphSuggestionsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphAnalysisSuggestionsResponse>>;
+            updateSuggestionStatus(input: UpdateGraphSuggestionStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphAnalysisSuggestion>>;
+            listSuggestions(input: ListGraphSuggestionsInput): Promise<PlatformGatewaySuccess<ListResult<any, "suggestions">>>;
+            listGraphChanges(input: ListGraphChangesInput): Promise<PlatformGatewaySuccess<ListResult<any, "changes">>>;
+            computeOrRequestAnalysis(input: ComputeOrRequestGraphAnalysisInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphAnalysisRecord>>;
+        };
+        graphRecommendations: {
+            listForTopic(input: GraphRecommendationListInput): Promise<PlatformGatewaySuccess<ListResult<any, "recommendations">>>;
+            getRecommendation(recommendationId: string): Promise<PlatformGatewaySuccess<GraphRecommendationRecord>>;
+            markRecommendationStatus(input: MarkGraphRecommendationStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphRecommendationRecord>>;
+        };
+        graphStateClassifier: {
+            classifyNode(input: ClassifyNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphStateClassification>>;
+            classifyTopic(input: ClassifyTopicInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ListResult<GraphStateClassification, "classifications">>>;
+            listClassifications(input: ListGraphStateClassificationsInput): Promise<PlatformGatewaySuccess<ListResult<GraphStateClassification, "classifications">>>;
+            recordClassification(input: RecordGraphStateClassificationInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<GraphStateClassification>>;
+        };
+        decisions: {
+            listJudgments(query: ListJudgmentsInput): Promise<PlatformGatewaySuccess<ListJudgmentsResponse>>;
+            getJudgment(judgmentId: string): Promise<PlatformGatewaySuccess<GetJudgmentResponse>>;
+            getJudgmentReadiness(query: {
+                topicId?: string;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<JudgmentReadinessResponse>>;
+            getJudgmentCalibration(query: GetJudgmentCalibrationInput): Promise<PlatformGatewaySuccess<JudgmentCalibrationResponse>>;
+            listPendingOutcomeReviews(query: ListPendingJudgmentOutcomeReviewInput): Promise<PlatformGatewaySuccess<ListResult<PendingJudgmentOutcomeRecord, "reviews">>>;
+            getJudgmentTransitionAuditIntegrity(query: GetJudgmentTransitionAuditIntegrityInput): Promise<PlatformGatewaySuccess<JudgmentTransitionAuditIntegrityResponse>>;
+            createJudgment(input: RecordJudgmentInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+            updateJudgmentOutcome(judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+        } & {
+            listPendingJudgmentOutcomeReview: (query: ListPendingJudgmentOutcomeReviewInput) => Promise<PlatformGatewaySuccess<ListResult<PendingJudgmentOutcomeRecord, "reviews">>>;
+            recordJudgment: (input: RecordJudgmentInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+            recordJudgmentOutcome: (judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+        };
+        workflow: {
+            listBranches(query: {
+                topicId?: string;
+                status?: WorkflowBranchStatus;
+                limit?: number;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<ListResult<WorkflowBranchRecord, "branches">>>;
+            createBranch(input: {
+                name: string;
+                topicId?: string;
+                description?: string;
+                metadata?: JsonObject;
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowBranchRecord>>;
+            listLenses(query: {
+                workspaceId?: string;
+                topicId?: string;
+                status
+                /**
+                 * Optional pack key for auto-install convenience.
+                 * When set, the SDK will call `packs.install()` on first use
+                 * to ensure the pack is available in the workspace.
+                 */
+                ? /**
+                 * Optional pack key for auto-install convenience.
+                 * When set, the SDK will call `packs.install()` on first use
+                 * to ensure the pack is available in the workspace.
+                 */: WorkflowLensStatus;
+                perspectiveType?: WorkflowLensPerspectiveType;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<ListResult<WorkflowLensRecord, "lenses">>>;
+            createLens(input: {
+                name: string;
+                workspaceId?: string;
+                topicId?: string;
+                description?: string;
+                perspectiveType: WorkflowLensPerspectiveType;
+                promptTemplates?: LensPromptTemplateReference[];
+                workflowTemplates?: LensWorkflowTemplate[];
+                taskTemplates?: LensTaskTemplate[];
+                filterCriteria?: JsonObject;
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowLensRecord>>;
+            applyLensToTopic(input: {
+                lensId: string;
+                topicId?: string;
+                metadata?: JsonObject;
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>;
+            removeLensFromTopic(input: {
+                lensId: string;
+                topicId?: string;
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>;
+            listWorktrees(query: {
+                topicId?: string;
+                branchId?: string;
+                status?: WorkflowWorktreeStatus;
+                groupBy?: "campaign" | "lane" | "flat";
+                lane?: string;
+                campaign?: number;
+                limit?: number;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<ListResult<WorkflowWorktreeRecord, "worktrees">>>;
+            listAllWorktrees(query?: {
+                status?: WorkflowWorktreeStatus;
+                groupBy?: "campaign" | "lane" | "flat";
+                lane?: string;
+                campaign?: number;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListWorktreesResponse>>;
+            listCampaigns(query?: {
+                topicId?: string;
+                status?: WorkflowWorktreeStatus;
+                limit?: number;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            createWorktree(input: AddWorktreeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>;
+            merge(worktreeId: string, input: MergeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<MergeWorktreeResponse>>;
+            activateWorktree(worktreeId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>;
+            updateWorktreeTargets(input: UpdateWorktreeTargetsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>;
+            completeWorktree(input: CompleteWorktreeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            advanceWorktreePhase(input: AdvanceWorktreePhaseInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            setWorktreePhase(input: SetWorktreePhaseInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            patchWorktreeState(input: PatchWorktreeStateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            bulkCreateWorktrees(input: BulkCreateWorktreesInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            openPullRequest(worktreeId: string, input: {
+                summary: string;
+                reviewers?: string[];
+                status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<OpenPullRequestResponse>>;
+            push(worktreeId: string, input: {
+                targetContext: string;
+                beliefIds?: string[];
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PushWorktreeResponse>>;
+            listTopics(query?: ListTopicsInput): Promise<PlatformGatewaySuccess<ListTopicsResponse>>;
+            switchTopicContext(input: SwitchTopicContextInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<SwitchTopicContextResponse>>;
+            createTask(input: CreateTaskInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<CreateTaskResponse>>;
+            completeTask(taskId: string, input: CompleteTaskInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<CompleteTaskResponse>>;
+            updateTask(taskId: string, input: UpdateTaskInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<UpdateTaskResponse>>;
+        } & {
+            addWorktree: (input: AddWorktreeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>;
+            createPillar: (input: {
+                name: string;
+                topicId?: string;
+                description?: string;
+                metadata?: JsonObject;
+            } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowBranchRecord>>;
+            createSprint: (input: AddWorktreeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>;
+            completeSprint: (worktreeId: string, input: MergeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<MergeWorktreeResponse>>;
+            requestReview: (worktreeId: string, input: {
+                summary: string;
+                reviewers?: string[];
+                status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+            }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<OpenPullRequestResponse>>;
+            publishFindings: (worktreeId: string, input: {
+                targetContext: string;
+                beliefIds?: string[];
+                metadata?: JsonObject;
+            }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PushWorktreeResponse>>;
+        };
+        audit: {
+            listEvents(query?: GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
+                limit?: number;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<ListResult<any, "events">>>;
+        };
+        authDevice: {
+            createDeviceCode(input?: DeviceCodeInput): Promise<DeviceCodeResponse>;
+            pollDeviceToken(deviceCode: string): Promise<DeviceTokenResponse>;
+        };
+        admin: {
+            listTenants(query?: {
+                status?: "provisioning" | "active" | "disabled" | "suspended" | "archived";
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<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<PlatformGatewaySuccess<unknown>>;
+            getControlObjectOwnership: () => Promise<PlatformGatewaySuccess<ControlObjectOwnershipContract>>;
+            getControlObjectOwnershipContract: () => Promise<PlatformGatewaySuccess<ControlObjectOwnershipContract>>;
+            listWorkspaces(query?: GatewayScope & {
+                status?: "active" | "archived";
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "workspaces">>>;
+            createWorkspace(input: 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<PlatformGatewaySuccess<unknown>>;
+            listMemberships(query?: GatewayScope & {
+                principalId?: string;
+                status?: "active" | "invited" | "revoked" | "expired";
+                role?: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "memberships">>>;
+            createMembership: (input: 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<PlatformGatewaySuccess<unknown>>;
+            updateMembership: (input: 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<PlatformGatewaySuccess<unknown>>;
+            upsertMembership: (input: 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<PlatformGatewaySuccess<unknown>>;
+            listTenantApiKeys(scope: GatewayScope & {
+                status?: "active" | "revoked" | "expired";
+            }): Promise<{
+                data: {
+                    keys: TenantApiKeyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createTenantApiKey(input: GatewayScope & {
+                label?: string;
+                scopes: string[];
+                expiresAt?: number;
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    key: TenantApiKeyRecord | null;
+                    plaintextKey: string | undefined;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            revokeTenantApiKey(keyId: string, input?: GatewayScope & {
+                reason?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTenantVaultSecrets(scope: GatewayScope): Promise<{
+                data: {
+                    secrets: TenantVaultSecretRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createTenantVaultSecret(input: GatewayScope & {
+                name: string;
+                description?: string;
+                value: string;
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    secret: TenantVaultSecretRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateTenantVaultSecret(secretId: string, input: GatewayScope & {
+                name: string;
+                description?: string;
+                value?: string;
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    secret: TenantVaultSecretRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteTenantVaultSecret(secretId: string, scope: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTenantSecrets(scope: GatewayScope & {
+                providerId?: string;
+                status?: "active" | "revoked";
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertTenantSecret(input: GatewayScope & {
+                providerId: string;
+                apiKey: string;
+                label?: string;
+                modelSlotIds?: string[];
+                passThroughOnly?: boolean;
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revokeTenantSecret(secretRef: string, input: GatewayScope & {
+                reason?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getTenantConfig(scope: GatewayScope & {
+                tenantId: string;
+            }): Promise<PlatformGatewaySuccess<TenantConfigRecord>>;
+            getTenantModelRouting(scope: GatewayScope & {
+                tenantId: string;
+            }): Promise<PlatformGatewaySuccess<TenantModelRoutingSnapshot>>;
+            upsertTenantConfig(input: GatewayScope & Omit<TenantConfigRecord, "updatedAt" | "updatedBy">, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TenantConfigRecord>>;
+            listGroups(scope?: GatewayScope & {
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            createGroup(input: GatewayScope & {
+                name: string;
+                groupKey?: string;
+                groupType?: string;
+                description?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateGroup(groupId: string, input: GatewayScope & {
+                name?: string;
+                description?: string;
+                workspaceId?: string;
+                clearWorkspaceId?: boolean;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deleteGroup(groupId: string, input?: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listGroupMembers(query: GatewayScope & {
+                groupId: string;
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            addGroupMember(input: GatewayScope & {
+                groupId: string;
+                principalId: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            removeGroupMember(input: GatewayScope & {
+                groupId: string;
+                principalId: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listPackGroupAssignments(query?: GatewayScope & {
+                groupId?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            assignPackToGroup(input: GatewayScope & {
+                groupId: string;
+                packKey: string;
+                packVersion?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            removePackFromGroup(input: GatewayScope & {
+                groupId: string;
+                packKey: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        identity: {
+            whoami(): Promise<PlatformGatewaySuccess<{
+                principalId: string;
+                principalType: "human" | "service" | "agent" | "user" | "group" | "external_viewer";
+                tenantId: string | null;
+                workspaceId: string | null;
+                scopes: string[];
+                roles: string[];
+                isPlatformAdmin: boolean;
+                isTenantAdmin: boolean;
+                isWorkspaceAdmin: boolean;
+                authMode: string | undefined;
+                sessionId: string | undefined;
+                delegatedBy: string | undefined;
+                expiresAt: number | undefined;
+            }>>;
+            listPrincipals(query?: GatewayScope & {
+                status?: string;
+                principalType?: string;
+                query?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "principals">>>;
+            createPrincipal(input: 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<PlatformGatewaySuccess<unknown>>;
+            updatePrincipal: (input: 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<PlatformGatewaySuccess<unknown>>;
+            upsertPrincipal: (input: 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<PlatformGatewaySuccess<unknown>>;
+            listKeys(query?: GatewayScope & {
+                principalId?: string;
+                status?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "keys">>>;
+            createKey(input: GatewayScope & {
+                principalId: string;
+                keyId?: string;
+                token?: string;
+                scopes?: string[];
+                environment?: "sandbox" | "production";
+                expiresInDays?: number;
+                rateLimitTier?: "free" | "developer" | "partner";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            rotateKey(keyId: string, input?: {
+                replacementKeyId?: string;
+                replacementToken?: string;
+                replacementExpiresInDays?: number;
+                gracePeriodHours?: number;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deleteKey: (keyId: string, input?: {
+                reason?: string;
+            }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            revokeKey: (keyId: string, input?: {
+                reason?: string;
+            }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            searchClerkUsers(q: string): Promise<PlatformGatewaySuccess<ClerkUserSearchResult[]>>;
+            getTenantConfig(input: TenantIdentityScope): Promise<PlatformGatewaySuccess<TenantIdentityConfigRecord>>;
+            updateTenantConfig(input: UpdateTenantConfigInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TenantIdentityConfigRecord>>;
+            listIntegrations(input: TenantIdentityScope): Promise<PlatformGatewaySuccess<ListResult<TenantIntegrationRecord, "integrations">>>;
+            upsertIntegration(input: UpsertTenantIntegrationInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TenantIntegrationRecord>>;
+            listSecrets(input: TenantIdentityScope): Promise<PlatformGatewaySuccess<ListResult<TenantSecretReference, "secrets">>>;
+            putSecretReference(input: PutTenantSecretReferenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TenantSecretReference>>;
+            evaluatePolicy(input: PolicyEvaluationInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PolicyDecisionRecord>>;
+            recordPolicyDecision(input: RecordPolicyDecisionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PolicyDecisionRecord>>;
+        };
+        policy: {
+            listDecisions(query?: GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "decisions">>>;
+            grant(input: GatewayScope & {
+                topicId: string;
+                permission: PermissionKind;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+                expiresAt?: number;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revoke(input: GatewayScope & {
+                topicId: string;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listWritePolicies(query?: GatewayScope & {
+                topicId?: string;
+                role?: string;
+                toolCategory?: string;
+                enabled?: boolean;
+            }): Promise<{
+                data: {
+                    policies: WritePolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createWritePolicy(input: WritePolicyCreateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    created: boolean;
+                    policy: WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateWritePolicy(id: string, input: WritePolicyUpdateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    updated: boolean;
+                    policy: WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteWritePolicy(id: string, scope?: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                id?: string;
+                deleted?: boolean;
+            }>>;
+            listRolePolicies(query?: GatewayScope): Promise<{
+                data: {
+                    policies: TenantPolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createRolePolicy(input: GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateRolePolicy(id: string, input: GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteRolePolicy(id: string, scope?: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            checkPermission(query: GatewayScope & {
+                topicId?: string;
+                permission?: PermissionKind;
+                principal?: string;
+                principalId?: string;
+                beliefClusterId?: string;
+            }): Promise<PlatformGatewaySuccess<PermissionDecision>>;
+            listAccessibleTopics(query?: GatewayScope & {
+                permission?: PermissionKind;
+                includeShared?: boolean;
+                principal?: string;
+                principalId?: string;
+                limit?: number;
+            }): Promise<{
+                data: {
+                    permission: PermissionKind;
+                    topics: {
+                        [key: string]: unknown;
+                        topicId?: string;
+                        name?: string;
+                        type?: string;
+                        isOwner?: boolean;
+                    }[];
+                    total: number;
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            filterByPermission(input: GatewayScope & {
+                topicIds?: string[];
+                permission?: PermissionKind;
+                principal?: string;
+                principalId?: string;
+            }): Promise<{
+                success: true;
+                data: {
+                    permission: PermissionKind;
+                    allowedTopicIds: string[];
+                    deniedTopics: Array<{
+                        topicId: string;
+                        reasonCode: string;
+                    }>;
+                    count: number;
+                };
+            }>;
+        };
+        answers: {
+            get(questionId: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+        ontology: {
+            list(filters?: GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<{
+                ontologies: unknown[];
+                total: number;
+                items: unknown[];
+                definitions: unknown[];
+            }>>;
+            get(id: string): Promise<PlatformGatewaySuccess<unknown>>;
+            bind(input: OntologyBindingInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            createDefinition(input: OntologyDefinitionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateDefinition(id: string, input: OntologyDefinitionUpdateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            archiveDefinition(id: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listVersions(ontologyId: string, filters?: GatewayScope & {
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<unknown, "versions">>>;
+            createVersion(ontologyId: string, input: OntologyVersionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            publishVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deprecateVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTopics(ontologyId: string): Promise<PlatformGatewaySuccess<ListResult<any, "topics">>>;
+        } & {
+            listDefinitions: (filters?: GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }) => Promise<PlatformGatewaySuccess<{
+                ontologies: unknown[];
+                total: number;
+                items: unknown[];
+                definitions: unknown[];
+            }>>;
+            getDefinition: (id: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            listTopicsByOntology: (ontologyId: string) => Promise<PlatformGatewaySuccess<ListResult<any, "topics">>>;
+        };
+        ontologyLinks: {
+            createLink(input: OntologyLinkWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<OntologyLinkRecord>>;
+            upsertLink(input: OntologyLinkWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<OntologyLinkRecord>>;
+            listLinksForNode(input: ListOntologyLinksForNodeInput): Promise<PlatformGatewaySuccess<ListResult<OntologyLinkRecord, "links">>>;
+            updateLinkStatus(input: UpdateOntologyLinkStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<OntologyLinkRecord>>;
+        };
+        orgGraphSearch: {
+            search(input: OrgGraphSearchInput): Promise<PlatformGatewaySuccess<OrgGraphSearchResponse>>;
+            getNode(input: GetOrgGraphNodeInput): Promise<PlatformGatewaySuccess<OrgGraphSearchResult>>;
+            listByProvenance(input: ListOrgGraphByProvenanceInput): Promise<PlatformGatewaySuccess<OrgGraphSearchResponse>>;
+            listPublishedFromWorkspace(input: ListPublishedFromWorkspaceInput): Promise<PlatformGatewaySuccess<OrgGraphSearchResponse>>;
+        };
+        functionSurface: {
+            sessionId: string;
+            activateWorktree(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            addEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            addWorktree(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            analyzeTopicDensity(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            answerQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            applyAutoBranching(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            applyLensToTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            applyOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            archiveBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            archiveEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            archiveOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            archiveQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            batchCreateEdges(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            batchCreateEpistemicNodes(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            beginBuildSession(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            bisectConfidence(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            broadcastMessage(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            checkPermission(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            claimFiles(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            compileContext(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            completeTask(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createAnswer(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createEdge(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createEpistemicContract(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createLens(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createOntologyVersion(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createTask(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            createTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            deprecateOntologyVersion(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            detectConfirmationBias(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            discover(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            discoverEntityConnections(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            endSession(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            evaluateContract(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            filterByPermission(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            findContradictions(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            findMissingQuestions(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            flagContradiction(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            forkBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            generateSessionHandoff(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getAgentInbox(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getAnswer(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getAuditTrail(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getChangeHistory(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getCodeContext(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getConfidenceHistory(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getContractStatus(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getFailureLog(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getFalsificationQuestions(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getGraphGaps(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getGraphNeighborhood(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getGraphStructureAnalysis(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getHighPriorityQuestions(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getLatticeCoverage(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getObservationContext(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getTopicCoverage(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getTopicGraphSpine(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            getTopicTree(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            heartbeatSession(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            whoami(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            ingestObservation(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            linkEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            linkEvidenceToBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            linkEvidenceToQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listActiveSessions(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listAllWorktrees(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listBeliefs(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listCampaigns(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listEpistemicNodes(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listGraphIntelligenceQueries(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listLenses(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listOntologies(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listQuestions(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listTasks(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listTopics(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            listWorktrees(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            manageWritePolicy(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            matchEntityType(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            materializeTopicGraph(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            merge(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            modulateConfidence(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            openPullRequest(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            pipelineSnapshot(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            publishOntologyVersion(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            push(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            queryLineage(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            recordAttempt(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            recordJudgment(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            recordScopeLearning(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            refineBelief(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            refineQuestion(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            registerSession(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            removeEdge(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            removeEdgesBetween(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            removeLensFromTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            resolveEffectiveOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            runGraphIntelligenceQuery(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            searchBeliefs(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            searchEvidence(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            seedBeliefLattice(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            sendAgentMessage(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            supersedeEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            traceEntityImpact(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            traverseGraph(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            triggerBeliefReview(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            updateEdge(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            updateEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            updateOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            updateQuestionStatus(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            updateTask(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            updateTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            updateWorktreeMetadata(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            updateWorktreeTargets(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            verifyEpistemicNode(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+        };
+        toolRegistry: {
+            listCatalog(input: ToolRegistryQuery): Promise<PlatformGatewaySuccess<ListResult<ToolCatalogEntry, "tools">>>;
+            listExecutable(input: ToolRegistryQuery): Promise<PlatformGatewaySuccess<ListResult<ToolCatalogEntry, "tools">>>;
+            listEffectiveTools(input: EffectiveToolsQuery): Promise<PlatformGatewaySuccess<ListResult<ToolCatalogEntry, "tools">>>;
+            upsertCoreTools(input: UpsertCoreToolsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ListResult<ToolCatalogEntry, "tools">>>;
+            setPackToolsStatus(input: SetPackToolsStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ListResult<ToolCatalogEntry, "tools">>>;
+            createAcl(input: CreateToolAclInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ToolAclRecord>>;
+            deleteAcl(input: DeleteToolAclInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                aclId: string;
+                deleted: boolean;
+            }>>;
+            registerCustomTool(input: RegisterCustomToolInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ToolCatalogEntry>>;
+        };
+        modelRuntime: {
+            listModels(input: ModelRuntimeScope): Promise<PlatformGatewaySuccess<ListResult<ModelRegistryRecord, "models">>>;
+            getModel(input: ModelRuntimeScope & {
+                modelId: string;
+            }): Promise<PlatformGatewaySuccess<ModelRegistryRecord>>;
+            listFunctionSlots(input: ModelRuntimeScope & {
+                functionName?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<ModelFunctionSlot, "slots">>>;
+            resolveSlot(input: ResolveModelSlotInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ModelFunctionSlot>>;
+            updateSlotConfig(input: UpdateModelSlotConfigInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ModelFunctionSlot>>;
+        };
+        packs: {
+            listCatalog(): Promise<PlatformGatewaySuccess<ListResult<any, "catalog">>>;
+            getDiscoveryCatalog(): Promise<PlatformGatewaySuccess<unknown>>;
+            getDiscoveryDetail(packKey: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listStates(query?: GatewayScope): Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+            getHealth(packKey: string, query?: GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            listTelemetry(query?: GatewayScope & {
+                lookbackHours?: number;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "telemetry">>>;
+            createEntitlement(input: PackEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            install(input: PackInstallInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            enable(input: PackEnableInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            disable(input: PackDisableInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            uninstall(input: PackUninstallInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upgrade(input: PackUpgradeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+        } & {
+            getCatalog: () => Promise<PlatformGatewaySuccess<ListResult<any, "catalog">>>;
+            getStates: (query?: GatewayScope) => Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+            getTelemetry: (query?: GatewayScope & {
+                lookbackHours?: number;
+                limit?: number;
+            }) => Promise<PlatformGatewaySuccess<ListResult<any, "telemetry">>>;
+            updateEntitlement: (input: PackEntitlementInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            upsertEntitlement: (input: PackEntitlementInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        reports: {
+            listTemplates: (args?: {
+                slug?: string;
+            }) => Promise<PlatformGatewaySuccess<ReportTemplatesResponse>>;
+            getTemplates: (args?: {
+                slug?: string;
+            }) => Promise<PlatformGatewaySuccess<ReportTemplatesResponse>>;
+            listReports: (input: TopicIdentifierInput, args?: {
+                summary?: boolean;
+            }) => Promise<PlatformGatewaySuccess<ListResult<any, "reports">>>;
+            getReport: (reportId: string) => Promise<PlatformGatewaySuccess<ReportWithSectionsResponse>>;
+        };
+        learning: {
+            listRecentExecutions: (args?: {
+                namespace?: string;
+                topicId?: string;
+                audienceMode?: string;
+                success?: boolean;
+                limit?: number;
+            } & TopicIdentifierInput) => Promise<PlatformGatewaySuccess<ListResult<any, "executions">>>;
+            getRecentExecutions: (args?: {
+                namespace?: string;
+                topicId?: string;
+                audienceMode?: string;
+                success?: boolean;
+                limit?: number;
+            } & TopicIdentifierInput) => Promise<PlatformGatewaySuccess<ListResult<any, "executions">>>;
+            getExecutionStats: (args?: {
+                namespace?: string;
+                topicId?: string;
+                audienceMode?: string;
+                hours?: number;
+            } & TopicIdentifierInput) => Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        mcp: {
+            bootstrapSession(input?: McpBootstrapSessionInput): Promise<McpBootstrapSessionResponse>;
+            checkWritePolicy(input: McpCheckWritePolicyInput): Promise<McpCheckWritePolicyResponse>;
+            beginBuildSession(input: McpBeginBuildSessionInput): Promise<McpBeginBuildSessionResponse>;
+            evaluateEngineeringContract(input: McpEvaluateEngineeringContractInput): Promise<McpContractEvaluationResponse>;
+            evaluateResearchContract(input: McpEvaluateResearchContractInput): Promise<McpContractEvaluationResponse>;
+        };
+        jobs: {
+            enqueue(input: EnqueueJobInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRecord>>;
+            list(input: JobsScope): Promise<PlatformGatewaySuccess<ListResult<JobRecord, "jobs">>>;
+            claim(input: ClaimJobInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRecord>>;
+            updateStatus(input: UpdateJobStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRecord>>;
+            retry(input: RetryJobInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRecord>>;
+            recordRunStart(input: RecordJobRunStartInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRunRecord>>;
+            recordRunFinish(input: RecordJobRunFinishInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<JobRunRecord>>;
+        };
+        telemetry: {
+            logSystemEvent(input: LogSystemEventInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                eventId?: string;
+                recorded: boolean;
+            }>>;
+            logToolCallsBatch(input: LogToolCallsBatchInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                recorded: number;
+            }>>;
+            recordEpistemicAudit(input: RecordEpistemicAuditInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                auditId?: string;
+                recorded: boolean;
+            }>>;
+            recordPolicyDecision(input: RecordTelemetryPolicyDecisionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                decisionId?: string;
+                recorded: boolean;
+            }>>;
+            startRun(input: StartTelemetryRunInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TelemetryRunRecord>>;
+            finishRun(input: FinishTelemetryRunInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TelemetryRunRecord>>;
+            listRuns(input: TelemetryScope): Promise<PlatformGatewaySuccess<ListResult<TelemetryRunRecord, "runs">>>;
+        };
+        harness: {
+            listAgentDefinitions(scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "agents">>>;
+            getAgentDefinition(agentId: string, scope?: GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            createAgentDefinition(input: HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateAgentDefinition(agentId: string, input: HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            invokeManagedAgentDefinition(agentId: string, input: Omit<HarnessInvokeManagedAgentInput, "agentDefinitionId">, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listAgentRuns(agentId: string, scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "runs">>>;
+            listToolDefinitions(scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+                gateClassification?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "tools">>>;
+            getToolDefinition(toolId: string, scope?: GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            createToolDefinition(input: HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateToolDefinition(toolId: string, input: HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            executeToolDefinition(toolId: string, input?: HarnessExecuteToolInput): Promise<PlatformGatewaySuccess<HarnessExecuteToolResult>>;
+            listRunEntries(scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "runs">>>;
+            startHarnessRun(input: HarnessStartRunInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getRunLedgerEntry(runId: string): Promise<PlatformGatewaySuccess<unknown>>;
+            reportHarnessRunEvent(runId: string, input: HarnessRunReportInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            heartbeatHarnessRun(runId: string, input: {
+                reportingToken: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            completeHarnessRun(runId: string, input: HarnessCompleteRunInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listPromptResolutions(query?: {
+                runId?: string;
+                promptName?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "prompts">>>;
+            getScopeTaxonomy(): Promise<PlatformGatewaySuccess<unknown>>;
+        } & {
+            registerAgentDefinition: (input: HarnessAgentWriteInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            listRunsForAgent: (agentId: string, scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }) => Promise<PlatformGatewaySuccess<ListResult<any, "runs">>>;
+            registerToolDefinition: (input: HarnessToolWriteInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            listRunLedgerEntries: (scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }) => Promise<PlatformGatewaySuccess<ListResult<any, "runs">>>;
+        };
+        schema: {
+            listPacks(scope?: GatewayScope): Promise<PlatformGatewaySuccess<ListResult<any, "packs">>>;
+            installPack(input: SchemaPackInstallInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getPack(packId: string, scope?: GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            listEntitlements(scope?: GatewayScope & {
+                packKey?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "entitlements">>>;
+            createEntitlement: (input: SchemaEntitlementInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            updateEntitlement: (input: SchemaEntitlementInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            upsertEntitlement: (input: SchemaEntitlementInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        audiences: {
+            listRegistry: (query?: GatewayScope & {
+                effective?: boolean;
+                status?: "active" | "disabled" | "archived";
+            }) => Promise<PlatformGatewaySuccess<ListResult<any, "registryEntries">>>;
+            getRegistry: (query?: GatewayScope & {
+                effective?: boolean;
+                status?: "active" | "disabled" | "archived";
+            }) => Promise<PlatformGatewaySuccess<ListResult<any, "registryEntries">>>;
+            createRegistryEntry: (input: AudienceRegistryInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            updateRegistryEntry: (input: AudienceRegistryInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            upsertRegistry: (input: AudienceRegistryInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            listGrants: (query?: GatewayScope & {
+                audienceKey?: string;
+                principalId?: string;
+                groupId?: string;
+                status?: "active" | "revoked" | "expired";
+            }) => Promise<PlatformGatewaySuccess<ListResult<any, "grants">>>;
+            getGrants: (query?: GatewayScope & {
+                audienceKey?: string;
+                principalId?: string;
+                groupId?: string;
+                status?: "active" | "revoked" | "expired";
+            }) => Promise<PlatformGatewaySuccess<ListResult<any, "grants">>>;
+            createGrant: (input: AudienceGrantInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            grant: (input: AudienceGrantInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            deleteGrant: (input: AudienceGrantRevokeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+            revokeGrant: (input: AudienceGrantRevokeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        topics: {
+            list(query?: TopicListInput): Promise<PlatformGatewaySuccess<TopicListResponse>>;
+            get(topicId: string): Promise<PlatformGatewaySuccess<TopicRecord>>;
+            create(input: TopicCreateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TopicRecord>>;
+            update(topicId: string, input: TopicUpdateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TopicRecord>>;
+            getTree(topicId: string, query?: TopicTreeQuery): Promise<PlatformGatewaySuccess<TopicTreeResponse>>;
+            getCoverage(topicId: string, query?: TopicCoverageQuery): Promise<PlatformGatewaySuccess<TopicCoverageResponse>>;
+            remove(topicId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            bulkCreate(input: TopicBulkCreateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+    };
+};
+
+export { type LucernClientConfig, createLucernClient };