@lucern/sdk 0.2.0-alpha.9 → 0.3.0-alpha.1

package/dist/client-B6aWUUwp.d.ts

@@ -0,0 +1,2552 @@
+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 { IdentityClientConfig, ClerkUserSearchResult } from './identityClient.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 { PacksClientConfig, PackInstallInput, PackEnableInput, PackDisableInput, PackEntitlementInput, PackUninstallInput, PackUpgradeInput } from './packsClient.js';
+import { CustomToolRegistration, RegisteredCustomTool } from './customTools.js';
+import { PolicyClientConfig, PermissionDecision, PermissionKind, WritePolicyRecord, WritePolicyCreateInput, WritePolicyUpdateInput, TenantPolicyRecord, TenantPolicyPermission } from './policyClient.js';
+import { GatewayClientConfig, 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 { AnswersClientConfig } from './answersClient.js';
+import { AuditClientConfig } from './auditClient.js';
+import { ContextClientConfig } from './contextClient.js';
+import { LensPromptTemplateReference, LensWorkflowTemplate, LensTaskTemplate } from './contracts/lens-workflow.contract.js';
+import { DecisionsClientConfig, RecordJudgmentInput, ListJudgmentsInput, RecordJudgmentOutcomeInput, GetJudgmentCalibrationInput, ListPendingJudgmentOutcomeReviewInput, GetJudgmentTransitionAuditIntegrityInput } from './decisionsClient.js';
+import { EvidenceClientConfig, EvidenceClassificationRequestConfig, ClassifyEvidenceResult, ClassifyEvidenceBatchItem, ClassifyEvidenceBatchResult } from './evidenceClient.js';
+import { GraphClientConfig, ListNodesInput, GetNodeInput, CreateNodeInput, UpdateNodeInput, BatchCreateNodesInput, SupersedeNodeInput, VerifyNodeInput, HardDeleteNodeInput, CreateEdgeInput, NeighborhoodInput, QueryNodesInput, ListEdgesInput, QueryEdgesInput, DeleteEdgeInput, TraverseInput, AnalyzeInput, BiasInput, GapsInput, SearchInput, PathInput, AnalyticsInput } from './graphClient.js';
+import { LearningClientConfig } from './learningClient.js';
+import { JsonObject, PlatformSourceRecord, ListResult, 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 { 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';
+
+type FunctionSurfaceClientConfig = GatewayClientConfig;
+type FunctionSurfaceInput = JsonObject;
+type FunctionSurfaceResult<T = unknown> = Promise<PlatformGatewaySuccess<T>>;
+declare const FUNCTION_SURFACE_METHOD_PATHS: readonly ["answers.answerQuestion", "answers.createAnswer", "answers.getAnswer", "beliefs.archiveBelief", "beliefs.bisectConfidence", "beliefs.createBelief", "beliefs.forkBelief", "beliefs.getBelief", "beliefs.getConfidenceHistory", "beliefs.listBeliefs", "beliefs.modulateConfidence", "beliefs.refineBelief", "beliefs.searchBeliefs", "bootstrap.generateSessionHandoff", "coding.getChangeHistory", "coding.getCodeContext", "coding.getFailureLog", "coding.recordAttempt", "context.analyzeTopicDensity", "context.applyAutoBranching", "context.compileContext", "context.discover", "context.discoverEntityConnections", "context.getLatticeCoverage", "context.recordScopeLearning", "context.seedBeliefLattice", "context.triggerBeliefReview", "contracts.createEpistemicContract", "contracts.evaluateContract", "contracts.getContractStatus", "contradictions.flagContradiction", "coordination.broadcastMessage", "coordination.claimFiles", "coordination.endSession", "coordination.getAgentInbox", "coordination.heartbeatSession", "coordination.listActiveSessions", "coordination.registerSession", "coordination.sendAgentMessage", "edges.createEdge", "edges.queryLineage", "evidence.addEvidence", "evidence.createEvidence", "evidence.getEvidence", "evidence.linkEvidence", "evidence.linkEvidenceToBelief", "evidence.linkEvidenceToQuestion", "evidence.listEvidence", "evidence.searchEvidence", "graph.detectConfirmationBias", "graph.findContradictions", "graph.getGraphGaps", "graph.getGraphNeighborhood", "graph.getGraphStructureAnalysis", "graph.getTopicCoverage", "graph.traceEntityImpact", "graph.traverseGraph", "identity.checkPermission", "identity.filterByPermission", "identity.whoami", "judgments.getAuditTrail", "judgments.recordJudgment", "lenses.applyLensToTopic", "lenses.createLens", "lenses.listLenses", "lenses.removeLensFromTopic", "observations.getObservationContext", "observations.ingestObservation", "ontologies.applyOntology", "ontologies.archiveOntology", "ontologies.createOntology", "ontologies.createOntologyVersion", "ontologies.deprecateOntologyVersion", "ontologies.getOntology", "ontologies.listOntologies", "ontologies.matchEntityType", "ontologies.publishOntologyVersion", "ontologies.resolveEffectiveOntology", "ontologies.updateOntology", "policy.manageWritePolicy", "questions.archiveQuestion", "questions.createQuestion", "questions.findMissingQuestions", "questions.getFalsificationQuestions", "questions.getHighPriorityQuestions", "questions.getQuestion", "questions.listQuestions", "questions.refineQuestion", "questions.updateQuestionStatus", "tasks.completeTask", "tasks.createTask", "tasks.listTasks", "tasks.updateTask", "topics.createTopic", "topics.getTopic", "topics.getTopicTree", "topics.listTopics", "topics.updateTopic", "worktrees.activateWorktree", "worktrees.addWorktree", "worktrees.listAllWorktrees", "worktrees.listCampaigns", "worktrees.listWorktrees", "worktrees.merge", "worktrees.openPullRequest", "worktrees.pipelineSnapshot", "worktrees.push", "worktrees.updateWorktreeMetadata", "worktrees.updateWorktreeTargets"];
+declare function createFunctionSurfaceClient(config?: FunctionSurfaceClientConfig): {
+    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>;
+    archiveOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+    archiveQuestion(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>;
+    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>;
+    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>;
+    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>;
+    listEvidence(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>;
+    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>;
+    removeLensFromTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+    resolveEffectiveOntology(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>;
+    traceEntityImpact(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+    traverseGraph(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+    triggerBeliefReview(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>;
+};
+
+type ClientConfig = BeliefsClientConfig | SourcesClientConfig | GraphClientConfig | DecisionsClientConfig | AnswersClientConfig | ContextClientConfig | WorkflowClientConfig | AuditClientConfig | AdminClientConfig | EvidenceClientConfig | IdentityClientConfig | PolicyClientConfig | PacksClientConfig | ReportsClientConfig | LearningClientConfig | FunctionSurfaceClientConfig | OntologyClientConfig | HarnessClientConfig | SchemaClientConfig | AudiencesClientConfig | TopicsClientConfig;
+type CustomToolInput = JsonObject;
+type CustomToolInvoker = (input?: CustomToolInput) => Promise<unknown>;
+type CustomToolNamespace = Record<string, CustomToolInvoker>;
+type GatewayDataEnvelope<T extends Record<string, unknown>> = PlatformGatewaySuccess<T> & T;
+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.
+     */
+    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;
+        }>>;
+    };
+    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: {
+            sourceId: string;
+            targetId: string;
+            edgeType: string;
+            topicId?: string;
+            confidence?: number;
+            weight?: number;
+            context?: string;
+            reasoning?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        update(input: Parameters<(input: {
+            edgeId: string;
+            weight?: number;
+            confidence?: number;
+            context?: string;
+            derivationType?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        remove(input: Parameters<(input: {
+            edgeId: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        removeBetween(input: Parameters<(input: {
+            fromNodeId: string;
+            toNodeId: string;
+            edgeType?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        batchCreate(input: Parameters<(input: {
+            edges: {
+                [x: string]: unknown;
+            }[];
+            skipLayerValidation?: boolean;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: 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: Parameters<(query: ListNodesInput) => Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>>[0]): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+            get(input: string | Parameters<(query: GetNodeInput) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            create(input: Parameters<(input: CreateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            update(input: Parameters<(input: UpdateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            batchCreate(input: Parameters<(input: BatchCreateNodesInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            supersede(input: Parameters<(input: SupersedeNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            verify(input: Parameters<(input: VerifyNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            hardDelete(input: Parameters<(input: HardDeleteNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+        createEdge(input: Parameters<(input: CreateEdgeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphEdge>>>[0]): 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;
+        }>;
+    };
+    judgments: {
+        create(input: RecordJudgmentInput): Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+        record(input: RecordJudgmentInput): Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+        list(query: Parameters<(query: ListJudgmentsInput) => Promise<PlatformGatewaySuccess<ListJudgmentsResponse>>>[0]): Promise<PlatformGatewaySuccess<ListJudgmentsResponse>>;
+        get(judgmentId: string): Promise<PlatformGatewaySuccess<GetJudgmentResponse>>;
+        recordOutcome(judgmentId: string, input: Parameters<(judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>>[1]): Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+        updateOutcome(judgmentId: string, input: Parameters<(judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>>[1]): 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>>;
+    };
+    worktrees: {
+        createBranch(input: Parameters<(input: {
+            name: string;
+            topicId?: string;
+            description?: string;
+            metadata?: JsonObject;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowBranchRecord>>>[0]): Promise<PlatformGatewaySuccess<WorkflowBranchRecord>>;
+        createLens(input: Parameters<(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>>>[0]): Promise<PlatformGatewaySuccess<WorkflowLensRecord>>;
+        listLenses(query: Parameters<(query: {
+            workspaceId?: string;
+            topicId?: string;
+            status?: WorkflowLensStatus;
+            perspectiveType?: WorkflowLensPerspectiveType;
+        } & TopicIdentifierInput) => Promise<PlatformGatewaySuccess<ListResult<WorkflowLensRecord, "lenses">>>>[0]): Promise<PlatformGatewaySuccess<ListResult<WorkflowLensRecord, "lenses">>>;
+        applyLensToTopic(input: Parameters<(input: {
+            lensId: string;
+            topicId?: string;
+            metadata?: JsonObject;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>>[0]): Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>;
+        removeLensFromTopic(input: Parameters<(input: {
+            lensId: string;
+            topicId?: string;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>>[0]): 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;
+            }[];
+        }>>;
+        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?: Parameters<(query?: {
+            status?: WorkflowWorktreeStatus;
+            groupBy?: "campaign" | "lane" | "flat";
+            lane?: string;
+            campaign?: number;
+            limit?: number;
+        }) => Promise<PlatformGatewaySuccess<ListWorktreesResponse>>>[0]): Promise<PlatformGatewaySuccess<ListWorktreesResponse>>;
+        merge(worktreeId: string, input: MergeInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        push(worktreeId: string, input: Parameters<(worktreeId: string, input: {
+            targetContext: string;
+            beliefIds?: string[];
+            metadata?: JsonObject;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PushWorktreeResponse>>>[1]): Promise<PlatformGatewaySuccess<PushWorktreeResponse>>;
+        openPullRequest(worktreeId: string, input: Parameters<(worktreeId: string, input: {
+            summary: string;
+            reviewers?: string[];
+            status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<OpenPullRequestResponse>>>[1]): Promise<PlatformGatewaySuccess<OpenPullRequestResponse>>;
+        pipelineSnapshot(topicId: string): FunctionSurfaceResult<unknown>;
+        complete(input: Parameters<(input: {
+            worktreeId: string;
+            keyFindings?: string[];
+            decisionsReached?: string[];
+            nextSteps?: string[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], 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: Parameters<(input: {
+            worktreeId: string;
+            patch: {
+                [x: string]: unknown;
+            };
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        bulkCreate(input: Parameters<(input: {
+            worktrees: unknown[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+    };
+    context: {
+        listTopics(query?: Parameters<(query?: TopicListInput) => Promise<PlatformGatewaySuccess<TopicListResponse>>>[0]): Promise<PlatformGatewaySuccess<TopicListResponse>>;
+        compile(topicId: string, input?: Parameters<(topicId: string, input?: CompileContextInput) => Promise<PlatformGatewaySuccess<PublicCompiledContext>>>[1]): Promise<PlatformGatewaySuccess<PublicCompiledContext>>;
+        recordScopeLearning(input: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+        discover(input: FunctionSurfaceInput): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        analyzeTopicDensity(input: FunctionSurfaceInput): FunctionSurfaceResult<unknown>;
+        applyAutoBranching(input: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+        seedBeliefLattice(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+        getLatticeCoverage(input?: FunctionSurfaceInput): 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;
+            }[];
+        }>>;
+    };
+    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<PlatformGatewaySuccess<TopicRecord>>;
+        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: Parameters<(input: TopicBulkCreateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, 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: any[];
+            total: number;
+            items: any[];
+            definitions: any[];
+        }>>;
+        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: any[];
+                total: number;
+                items: any[];
+                definitions: any[];
+            }>>;
+            get(id: string): Promise<PlatformGatewaySuccess<unknown>>;
+            bind(input: OntologyBindingInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listDefinitions(filters?: GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<{
+                ontologies: any[];
+                total: number;
+                items: any[];
+                definitions: any[];
+            }>>;
+            getDefinition(id: 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<any, "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">>>;
+            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): FunctionSurfaceResult<unknown>;
+        sendAgentMessage(input: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+        broadcastMessage(input: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+        getInbox(input?: FunctionSurfaceInput): FunctionSurfaceResult<unknown>;
+        getAgentInbox(input?: FunctionSurfaceInput): 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: boolean;
+            data: {
+                permission: PermissionKind;
+                allowedTopicIds: string[];
+                deniedTopics: {
+                    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: boolean;
+                data: {
+                    permission: PermissionKind;
+                    allowedTopicIds: string[];
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                    count: number;
+                };
+            }>;
+        };
+    };
+    observations: {
+        ingest(input: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+        ingestObservation(input: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+        getContext(input: FunctionSurfaceInput): FunctionSurfaceResult<unknown>;
+        getObservationContext(input: FunctionSurfaceInput): FunctionSurfaceResult<unknown>;
+    };
+    coding: {
+        getCodeContext(input: FunctionSurfaceInput): FunctionSurfaceResult<unknown>;
+        getChangeHistory(input: FunctionSurfaceInput): FunctionSurfaceResult<unknown>;
+        recordAttempt(input: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+        getFailureLog(input: FunctionSurfaceInput): 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): FunctionSurfaceResult<unknown>;
+    };
+    tools: {
+        register(registration: CustomToolRegistration): RegisteredCustomTool;
+        unregister(fullName: string): boolean;
+        list(): RegisteredCustomTool[];
+        clear(): void;
+        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(scope?: Parameters<(query?: GatewayScope) => Promise<PlatformGatewaySuccess<ListResult<any, "states">>>>[0]): Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+        states(scope?: Parameters<(query?: GatewayScope) => Promise<PlatformGatewaySuccess<ListResult<any, "states">>>>[0]): Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+        install(input: Parameters<(input: PackInstallInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        enable(input: Parameters<(input: PackEnableInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        disable(input: Parameters<(input: PackDisableInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    nodes: {
+        list(query: Parameters<(query: ListNodesInput) => Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>>[0]): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+        get(input: string | Parameters<(query: GetNodeInput) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+        create(input: Parameters<(input: CreateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+        update(input: Parameters<(input: UpdateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+        batchCreate(input: Parameters<(input: BatchCreateNodesInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        supersede(input: Parameters<(input: SupersedeNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        verify(input: Parameters<(input: VerifyNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        hardDelete(input: Parameters<(input: HardDeleteNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    };
+    identity: {
+        whoami(): Promise<PlatformGatewaySuccess<{
+            principalId: string;
+            principalType: "user" | "human" | "service" | "group" | "external_viewer" | "agent";
+            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: "user" | "human" | "service" | "group" | "external_viewer" | "agent";
+            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;
+        }>;
+    };
+    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>>;
+        };
+        graph: {
+            listNodes(query: ListNodesInput): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+            queryNodes(query: QueryNodesInput): 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">>>;
+            queryEdges(query: QueryEdgesInput): 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>>>;
+            getNeighborhood(query: NeighborhoodInput): Promise<PlatformGatewaySuccess<GraphNeighborhoodResponse>>;
+            getPath(query: PathInput): Promise<PlatformGatewaySuccess<GraphPathResponse>>;
+            getAnalytics(query?: AnalyticsInput): Promise<PlatformGatewaySuccess<GraphAnalyticsResponse>>;
+        };
+        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">>>;
+            listPendingJudgmentOutcomeReview(query: ListPendingJudgmentOutcomeReviewInput): Promise<PlatformGatewaySuccess<ListResult<PendingJudgmentOutcomeRecord, "reviews">>>;
+            getJudgmentTransitionAuditIntegrity(query: GetJudgmentTransitionAuditIntegrityInput): Promise<PlatformGatewaySuccess<JudgmentTransitionAuditIntegrityResponse>>;
+            createJudgment(input: RecordJudgmentInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+            recordJudgment(input: RecordJudgmentInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+            updateJudgmentOutcome(judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+            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?: 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>>;
+            addWorktree(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>>;
+            createPillar(input: {
+                name: string;
+                topicId?: string;
+                description?: string;
+                metadata?: JsonObject;
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowBranchRecord>>;
+            createSprint(input: {
+                title: string;
+                topicId?: string;
+                branchId?: string;
+                hypothesis?: string;
+                beliefIds?: string[];
+            } & TopicIdentifierInput, 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">>>;
+        };
+        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: "user" | "human" | "service" | "group" | "external_viewer" | "agent";
+                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[]>>;
+        };
+        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: boolean;
+                data: {
+                    permission: PermissionKind;
+                    allowedTopicIds: string[];
+                    deniedTopics: {
+                        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: any[];
+                total: number;
+                items: any[];
+                definitions: any[];
+            }>>;
+            get(id: string): Promise<PlatformGatewaySuccess<unknown>>;
+            bind(input: OntologyBindingInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listDefinitions(filters?: GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<{
+                ontologies: any[];
+                total: number;
+                items: any[];
+                definitions: any[];
+            }>>;
+            getDefinition(id: 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<any, "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">>>;
+            listTopicsByOntology(ontologyId: string): Promise<PlatformGatewaySuccess<ListResult<any, "topics">>>;
+        };
+        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>;
+            archiveOntology(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            archiveQuestion(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>;
+            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>;
+            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>;
+            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>;
+            listEvidence(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>;
+            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>;
+            removeLensFromTopic(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            resolveEffectiveOntology(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>;
+            traceEntityImpact(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            traverseGraph(input?: FunctionSurfaceInput, idempotencyKey?: string): FunctionSurfaceResult<unknown>;
+            triggerBeliefReview(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>;
+        };
+        packs: {
+            listCatalog(): Promise<PlatformGatewaySuccess<ListResult<any, "catalog">>>;
+            getCatalog(): Promise<PlatformGatewaySuccess<ListResult<any, "catalog">>>;
+            getDiscoveryCatalog(): Promise<PlatformGatewaySuccess<unknown>>;
+            getDiscoveryDetail(packKey: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listStates(query?: GatewayScope): Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+            getStates(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">>>;
+            getTelemetry(query?: GatewayScope & {
+                lookbackHours?: number;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "telemetry">>>;
+            createEntitlement(input: PackEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateEntitlement(input: PackEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertEntitlement(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>>;
+        };
+        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>>;
+        };
+        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>>;
+            registerAgentDefinition(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">>>;
+            listRunsForAgent(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>>;
+            registerToolDefinition(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">>>;
+            listRunLedgerEntries(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>>;
+        };
+        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 FunctionSurfaceClientConfig as F, type LucernClientConfig as L, type FunctionSurfaceInput as a, type FunctionSurfaceResult as b, createLucernClient as c, FUNCTION_SURFACE_METHOD_PATHS as d, createFunctionSurfaceClient as e };