@lucern/sdk 0.2.0-alpha.1

package/dist/packages/sdk/src/client.d.ts

@@ -0,0 +1,1610 @@
+import { type AdminClientConfig } from "./adminClient";
+import { type AnswersClientConfig } from "./answersClient";
+import { type AudiencesClientConfig } from "./audiencesClient";
+import { type AuditClientConfig } from "./auditClient";
+import { type BeliefsClientConfig } from "./beliefsClient";
+import { type PlatformGatewaySuccess } from "./coreClient";
+import { type CustomToolRegistration } from "./customTools";
+import { type DecisionsClientConfig, type RecordJudgmentInput } from "./decisionsClient";
+import { type ContextClientConfig } from "./contextClient";
+import { type GraphClientConfig } from "./graphClient";
+import { type HarnessClientConfig } from "./harnessClient";
+import { type IdentityClientConfig } from "./identityClient";
+import { type LearningClientConfig } from "./learningClient";
+import { type McpParityClientConfig } from "./mcpParityClient";
+import { type OntologyClientConfig } from "./ontologyClient";
+import { type PacksClientConfig } from "./packsClient";
+import { type PolicyClientConfig } from "./policyClient";
+import { type ReportsClientConfig } from "./reportsClient";
+import { type SchemaClientConfig } from "./schemaClient";
+import { type TopicsClientConfig } from "./topicsClient";
+import type { JsonObject, PlatformGraphEdge, PlatformGraphNode } from "./types";
+import { type AddWorktreeInput, type CompleteTaskInput, type CreateTaskInput, type MergeInput, type UpdateTaskInput, type WorkflowClientConfig } from "./workflowClient";
+type ClientConfig = BeliefsClientConfig | GraphClientConfig | DecisionsClientConfig | AnswersClientConfig | ContextClientConfig | WorkflowClientConfig | AuditClientConfig | AdminClientConfig | IdentityClientConfig | PolicyClientConfig | PacksClientConfig | ReportsClientConfig | LearningClientConfig | McpParityClientConfig | 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;
+    projectId?: string;
+    text?: string;
+    canonicalText?: string;
+    formulation?: string;
+    rationale?: string;
+    worktreeId?: string;
+    pillar?: string;
+    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 = {
+    confidence: number;
+    trigger?: "evidence_added" | "evidence_removed" | "contradiction_detected" | "contradiction_resolved" | "manual" | "decay" | "agent_assessment" | "merge_outcome" | "sprint_outcome" | "sprint_completed" | "worktree_outcome" | "worktree_completed";
+    rationale: string;
+    certainty?: number;
+    maxInlinePropagationTargets?: number;
+};
+export type LucernClientConfig = ClientConfig & {
+    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;
+    environment?: "sandbox" | "production";
+};
+/**
+ * Create the high-level Lucern SDK facade.
+ */
+export declare function createLucernClient(config?: LucernClientConfig): {
+    config: LucernClientConfig;
+    version: string;
+    search(query: string, options?: {
+        topicId?: string;
+        projectId?: string;
+        types?: string[];
+        status?: string;
+        minConfidence?: number;
+        limit?: number;
+        cursor?: string;
+    }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-search/src/search").SearchResponse>>;
+    events: {
+        list(query?: Parameters<(query: Parameters<(query?: import("@/lucern/packages/events/src/types").EventListQuery) => Promise<import("@/lucern/packages/client-core/src/events").EventsListResponse>>[0]) => Promise<import("@/lucern/packages/client-core/src/events").EventsListResponse>>[0]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").EventListResult>>;
+        replay(input: Parameters<(input: Parameters<(input: import("@/lucern/packages/events/src/types").ReplayEventsInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/events").EventsReplayResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/events/src/types").ReplayEventsInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/events").EventsReplayResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/events").EventsReplayResponse>>[0]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").ReplayEventsResult>>;
+    };
+    beliefs: {
+        create(input: BeliefsCompatCreateInput): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefRecord>>;
+        get(nodeId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefRecord>>;
+        refine(nodeId: string, textOrInput: string | {
+            text: string;
+            rationale?: string;
+        }, rationale?: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefRecord>>;
+        updateConfidence(nodeId: string, input: BeliefsCompatUpdateConfidenceInput): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefConfidenceUpdateResult>>;
+        modulateConfidence(nodeId: string, input: BeliefsCompatUpdateConfidenceInput): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefConfidenceUpdateResult>>;
+        fork(nodeId: string, input: BeliefsCompatForkInput): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefRecord & {
+            parentBeliefId: string;
+            forkReason: string;
+        }>>;
+        archive(nodeId: string, input?: string | {
+            reason?: string;
+            rationale?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefArchiveResult>>;
+        list(args: {
+            topicId?: string;
+            projectId?: string;
+            worktreeId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefListResult>>;
+        search: (args: {
+            query: string;
+            topicId?: string;
+            projectId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+        }) => Promise<{
+            results: Record<string, unknown>[];
+        }>;
+        lineage(nodeId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefLineageResult>>;
+        confidenceHistory(nodeId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefConfidenceHistoryResult>>;
+        createContract(nodeId: string, input: Parameters<(id: string, input: Parameters<(id: string, input: import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefContractCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>>[1], idempotencyKey?: Parameters<(id: string, input: import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefContractCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>>[2]) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefContractCreateResult>>;
+        bisect(nodeId: string, input: Parameters<(id: string, input: Parameters<(id: string, input: Omit<import("@/lucern/packages/domain-beliefs/src/beliefs").BisectBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>>[1], idempotencyKey?: Parameters<(id: string, input: Omit<import("@/lucern/packages/domain-beliefs/src/beliefs").BisectBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>>[2]) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefBisectResult>>;
+    };
+    webhooks: {
+        create(input: Parameters<(input: Parameters<(input: import("@/lucern/packages/events/src/types").WebhookCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/events/src/types").WebhookCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksCreateResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksCreateResponse>>[0]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookRecord>>;
+        list(query?: Parameters<(query?: Parameters<(query?: import("@/lucern/packages/client-core/src/webhooks").WebhookListQuery) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksListResponse>>[0]) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksListResponse>>[0]): Promise<GatewayDataEnvelope<{
+            webhooks: import("@/lucern/packages/events/src/types").WebhookRecord[];
+        }>>;
+        get(id: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookRecord>>;
+        update(id: string, input: Parameters<(id: string, input: Parameters<(id: string, input: import("@/lucern/packages/events/src/types").WebhookUpdateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksUpdateResponse>>[1], idempotencyKey?: Parameters<(id: string, input: import("@/lucern/packages/events/src/types").WebhookUpdateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksUpdateResponse>>[2]) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksUpdateResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookRecord>>;
+        delete(id: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/client-core/src/webhooks").WebhookDeleteResult>>;
+        test(id: string, input?: Parameters<(id: string, input?: Parameters<(id: string, input?: {
+            topicId?: string;
+        }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksTestResponse>>[1], idempotencyKey?: Parameters<(id: string, input?: {
+            topicId?: string;
+        }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksTestResponse>>[2]) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksTestResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookTestResult>>;
+        deliveries(id: string, query?: Parameters<(id: string, query?: Parameters<(id: string, query?: import("@/lucern/packages/client-core/src/webhooks").WebhookDeliveriesQuery) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksDeliveriesResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksDeliveriesResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookDeliveriesResult>>;
+        health(id: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookHealthResult>>;
+    };
+    edges: {
+        create(args: {
+            sourceId: string;
+            targetId: string;
+            edgeType: string;
+            topicId?: string;
+            projectId?: string;
+            confidence?: number;
+            weight?: number;
+            context?: string;
+            reasoning?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/edges").EdgeRecord>>;
+        list(args: {
+            sourceId: string;
+            edgeType?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/edges").EdgeListResult>>;
+        traverse(args: {
+            startNode: string;
+            direction?: string;
+            maxDepth?: number;
+            topicId?: string;
+            projectId?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/edges").EdgeTraversalResult>>;
+    };
+    evidence: {
+        create(args: {
+            text?: string;
+            canonicalText?: string;
+            topicId?: string;
+            projectId?: 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<import("@/lucern/packages/domain-evidence/src/evidence").EvidenceRecord>>;
+        add: (args: {
+            text?: string;
+            canonicalText?: string;
+            topicId?: string;
+            projectId?: 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<import("@/lucern/packages/domain-evidence/src/evidence").EvidenceRecord | {
+            edgeId: string;
+            id: string;
+            nodeId: string;
+            evidenceId: string;
+            globalId?: string;
+            topicId?: string;
+            text: string;
+            title?: string;
+            kind?: string;
+            source?: string;
+            sourceType?: string;
+            externalSourceType?: string;
+            status?: string;
+            relation?: "supports" | "contradicts" | "neutral";
+            confidence?: number;
+            linkedBeliefId?: string;
+            linkedQuestionId?: string;
+            createdAt?: number;
+            updatedAt?: number;
+            metadata?: Record<string, unknown>;
+        }>;
+        get(evidenceId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-evidence/src/evidence").EvidenceRecord>>;
+        list(args: {
+            topicId?: string;
+            projectId?: string;
+            targetId?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-evidence/src/evidence").EvidenceListResult>>;
+        search(args: {
+            q?: string;
+            query?: string;
+            topicId?: string;
+            projectId?: string;
+            targetId?: string;
+            methodology?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-evidence/src/evidence").EvidenceSearchPage>>;
+        link(args: {
+            evidenceId: string;
+            targetId?: string;
+            beliefId?: string;
+            questionId?: string;
+            targetType?: "belief" | "question" | string;
+            weight?: number;
+            rationale?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-evidence/src/evidence").LinkEvidenceResult>>;
+        linkToBelief(args: {
+            evidenceId: string;
+            beliefId: string;
+            weight: number;
+            rationale?: string;
+        }): Promise<{
+            beliefId: string;
+            edgeId: string;
+            evidenceId: string;
+            targetId: string;
+            targetType: import("@/lucern/packages/domain-evidence/src/evidence").EvidenceTargetType;
+            weight: number;
+            questionId?: string;
+        }>;
+    };
+    questions: {
+        create(args: {
+            text: string;
+            topicId?: string;
+            projectId?: string;
+            priority?: string;
+            linkedBeliefId?: string;
+            metadata?: JsonObject;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionRecord>>;
+        get(questionId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionRecord>>;
+        refine(questionId: string, text: string, refinementReason?: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionRecord & {
+            previousText: string;
+            updatedText: string;
+        }>>;
+        list(args: {
+            topicId?: string;
+            projectId?: string;
+            status?: string;
+            priority?: string;
+            worktreeId?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionListResult>>;
+        updateStatus(questionId: string, status: string, rationale?: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionRecord & {
+            previousStatus: string;
+            newStatus: string;
+        }>>;
+        answer(questionId: string, input: {
+            text: string;
+            confidence?: string;
+            evidenceIds?: string[];
+            rationale?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionAnswerResult>>;
+        archive(questionId: string, reason?: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionArchiveResult>>;
+        linkEvidence(args: {
+            evidenceId: string;
+            questionId: string;
+            relevance?: number;
+            weight?: number;
+            rationale?: string;
+        }): Promise<{
+            questionId: string;
+            relevance: number | undefined;
+            edgeId: string;
+            evidenceId: string;
+            targetId: string;
+            targetType: import("@/lucern/packages/domain-evidence/src/evidence").EvidenceTargetType;
+            weight: number;
+            beliefId?: string;
+        }>;
+        getHighPriority(args: {
+            topicId?: string;
+            projectId?: string;
+            limit?: number;
+            includeAnswered?: boolean;
+        }): Promise<{
+            questions: import("@/lucern/packages/domain-questions/src/questions").QuestionRecord[];
+        }>;
+        findMissing(args: {
+            topicId?: string;
+            projectId?: string;
+            minConfidence?: number;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphGapsResult>>;
+    };
+    graph: {
+        createEdge(input: Parameters<(input: import("./graphClient").CreateEdgeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphEdge>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphEdge>>;
+        neighborhood(args: Parameters<(query: import("./graphClient").NeighborhoodInput) => Promise<PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>>[0]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphNeighborhoodResult>>;
+        queryLineage: (nodeId: string, depth?: number) => Promise<{
+            chain: {
+                nodeId: string;
+                relation: string;
+            }[];
+            forkTree: {
+                nodeId: string;
+                parentCount: number;
+                childCount: number;
+                children: never[];
+            };
+            depth: number;
+            beliefId: string;
+            lineage: import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefLineageEntry[];
+        }>;
+        getConfidenceHistory: (nodeId: string) => Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefConfidenceHistoryResult>>;
+        getAuditTrail: (nodeId: string, limit?: number) => Promise<{
+            entries: {
+                action: string;
+                actor: string;
+                timestamp: number;
+                rationale: string;
+                before: string | number | boolean | import("./types").JsonArray | JsonObject | null;
+                after: string | number | boolean | import("./types").JsonArray | JsonObject | null;
+            }[];
+        }>;
+        traverse(args: {
+            startNode: string;
+            direction?: string;
+            maxDepth?: number;
+            topicId?: string;
+            projectId?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphTraverseResult>>;
+        analyze(args: {
+            topicId?: string;
+            projectId?: string;
+            limit?: number;
+            metric?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphAnalyzeResult>>;
+        bias(args: {
+            topicId?: string;
+            projectId?: string;
+            threshold?: number;
+            limit?: number;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphBiasResult>>;
+        gaps(args: {
+            topicId?: string;
+            projectId?: string;
+            minConfidence?: number;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphGapsResult>>;
+        falsify(args: {
+            topicId?: string;
+            projectId?: string;
+            beliefId?: string;
+            beliefIds?: string[];
+            minConfidence?: number;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphFalsifyResult>>;
+        traceEntityImpact(args: {
+            nodeId: string;
+            topicId?: string;
+            projectId?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        searchBeliefs: (args: {
+            query: string;
+            topicId?: string;
+            projectId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+        }) => Promise<{
+            results: Record<string, unknown>[];
+        }>;
+        findContradictions: (args: {
+            topicId?: string;
+            projectId?: 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<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefBisectResult>>;
+        listBeliefs: (args: {
+            topicId?: string;
+            projectId?: string;
+            worktreeId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefRecord[]>;
+        detectConfirmationBias(topicId: string, threshold?: number, projectId?: string): Promise<{
+            topicId: string;
+            projectId: string;
+            threshold: number;
+            success: true;
+            data: import("@/lucern/packages/domain-graph/src/graph").GraphBiasResult;
+            correlationId: string;
+            policyTraceId: string | null;
+            idempotentReplay: boolean;
+            metric: "confirmation_bias";
+            beliefs: import("@/lucern/packages/domain-graph/src/graph").GraphBiasBelief[];
+            payload: Record<string, unknown>;
+        }>;
+        getStructureAnalysis(topicId: string, projectId?: string): Promise<{
+            topicId: string;
+            projectId: string;
+            success: true;
+            data: import("@/lucern/packages/domain-graph/src/graph").GraphAnalyzeResult;
+            correlationId: string;
+            policyTraceId: string | null;
+            idempotentReplay: boolean;
+            metric: string;
+            payload: Record<string, unknown>;
+        }>;
+        getFalsificationQuestions(topicId: string, beliefIds?: string[], projectId?: string): Promise<{
+            topicId: string;
+            projectId: string;
+            questions: import("@/lucern/packages/domain-graph/src/graph").GraphFalsificationQuestion[];
+        }>;
+    };
+    judgments: {
+        create(input: RecordJudgmentInput): Promise<PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
+        record(input: RecordJudgmentInput): Promise<PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
+        list(query: Parameters<(query: import("./decisionsClient").ListJudgmentsInput) => Promise<PlatformGatewaySuccess<import("./types").ListJudgmentsResponse>>>[0]): Promise<PlatformGatewaySuccess<import("./types").ListJudgmentsResponse>>;
+        get(judgmentId: string): Promise<PlatformGatewaySuccess<import("./types").GetJudgmentResponse>>;
+        recordOutcome(judgmentId: string, input: Parameters<(judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>>[1]): Promise<PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
+        updateOutcome(judgmentId: string, input: Parameters<(judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>>[1]): Promise<PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
+        readiness(topicId: string, projectId?: string): Promise<PlatformGatewaySuccess<import("./types").JudgmentReadinessResponse>>;
+        calibration(topicId: string, projectId?: string): Promise<PlatformGatewaySuccess<import("./types").JudgmentCalibrationResponse>>;
+        pendingOutcomeReview(topicId: string, projectId?: string): Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").PendingJudgmentOutcomeRecord, "reviews">>>;
+        transitionAuditIntegrity(args: {
+            topicId?: string;
+            projectId?: string;
+            judgmentId?: string;
+            includePassing?: boolean;
+        }): Promise<PlatformGatewaySuccess<import("./types").JudgmentTransitionAuditIntegrityResponse>>;
+    };
+    worktrees: {
+        createBranch(input: Parameters<(input: {
+            name: string;
+            topicId?: string;
+            projectId?: string;
+            description?: string;
+            metadata?: JsonObject;
+        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").WorkflowBranchRecord>>>[0]): Promise<PlatformGatewaySuccess<import("./types").WorkflowBranchRecord>>;
+        createLens(input: Parameters<(input: {
+            name: string;
+            workspaceId?: string;
+            topicId?: string;
+            projectId?: string;
+            description?: string;
+            perspectiveType: import("./workflowClient").WorkflowLensPerspectiveType;
+            promptTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensPromptTemplateReference[];
+            workflowTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensWorkflowTemplate[];
+            taskTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensTaskTemplate[];
+            filterCriteria?: JsonObject;
+        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").WorkflowLensRecord>>>[0]): Promise<PlatformGatewaySuccess<import("./types").WorkflowLensRecord>>;
+        listLenses(query: Parameters<(query: {
+            workspaceId?: string;
+            topicId?: string;
+            projectId?: string;
+            status?: import("./workflowClient").WorkflowLensStatus;
+            perspectiveType?: import("./workflowClient").WorkflowLensPerspectiveType;
+        } & import("./types").TopicIdentifierInput) => Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowLensRecord, "lenses">>>>[0]): Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowLensRecord, "lenses">>>;
+        applyLensToTopic(input: Parameters<(input: {
+            lensId: string;
+            topicId?: string;
+            projectId?: string;
+            metadata?: JsonObject;
+        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>>[0]): Promise<PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>;
+        removeLensFromTopic(input: Parameters<(input: {
+            lensId: string;
+            topicId?: string;
+            projectId?: string;
+        } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>>[0]): Promise<PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>;
+        create(input: AddWorktreeInput): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesCreateResponse>;
+        add(input: AddWorktreeInput): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesCreateResponse>;
+        list(query: Parameters<(query: {
+            topicId?: string;
+            projectId?: string;
+            branchId?: string;
+            status?: import("./workflowClient").WorkflowWorktreeStatus;
+            track?: string;
+            executionBand?: number;
+            limit?: number;
+        } & import("./types").TopicIdentifierInput) => Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowWorktreeRecord, "worktrees">>>>[0]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesListResponse>;
+        activate(worktreeId: string): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesActivateResponse>;
+        updateMetadata(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesUpdateResponse>;
+        update(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesUpdateResponse>;
+        updateTargets(input: Parameters<(input: import("./workflowClient").UpdateWorktreeTargetsInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>>[0]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesTargetsResponse>;
+        listAll(query?: Parameters<(query?: {
+            status?: import("./workflowClient").WorkflowWorktreeStatus;
+            track?: string;
+            executionBand?: number;
+            limit?: number;
+        }) => Promise<PlatformGatewaySuccess<import("./types").ListWorktreesResponse>>>[0]): Promise<PlatformGatewaySuccess<import("./types").ListWorktreesResponse>>;
+        merge(worktreeId: string, input: MergeInput): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesMergeResponse>;
+        push(worktreeId: string, input: Parameters<(worktreeId: string, input: {
+            targetContext: string;
+            beliefIds?: string[];
+            metadata?: JsonObject;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").PushWorktreeResponse>>>[1]): Promise<PlatformGatewaySuccess<import("./types").PushWorktreeResponse>>;
+        openPullRequest(worktreeId: string, input: Parameters<(worktreeId: string, input: {
+            summary: string;
+            reviewers?: string[];
+            status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").OpenPullRequestResponse>>>[1]): Promise<PlatformGatewaySuccess<import("./types").OpenPullRequestResponse>>;
+        pipelineSnapshot(topicId: string): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    context: {
+        listTopics(query?: Parameters<(query?: import("./topicsClient").TopicListInput) => Promise<PlatformGatewaySuccess<import("./types").TopicListResponse>>>[0]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsListResponse>;
+        compile(topicId: string, input?: Parameters<(topicId: string, input?: import("@/lucern/packages/client-core/src/context").CompileContextInput) => Promise<PlatformGatewaySuccess<import("@/lucern/contracts/context-pack.contract").PublicCompiledContext>>>[1]): Promise<PlatformGatewaySuccess<import("@/lucern/contracts/context-pack.contract").PublicCompiledContext>>;
+        recordScopeLearning(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        discover(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        analyzeTopicDensity(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        applyAutoBranching(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        seedBeliefLattice(input?: Parameters<(args?: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        getLatticeCoverage(input?: Parameters<(args?: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        matchEntityType(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchResult>>;
+        discoverEntityConnections(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        triggerBeliefReview(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    tasks: {
+        create(input: CreateTaskInput): Promise<import("@/lucern/packages/client-core/src/tasks").TasksCreateResponse>;
+        complete(taskId: string, input: CompleteTaskInput): Promise<import("@/lucern/packages/client-core/src/tasks").TasksCompleteResponse>;
+        update(taskId: string, input: UpdateTaskInput): Promise<import("@/lucern/packages/client-core/src/tasks").TasksUpdateResponse>;
+        list(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<import("@/lucern/packages/client-core/src/tasks").TasksListResponse>;
+    };
+    topics: {
+        list(input?: Parameters<(query?: import("./topicsClient").TopicListInput) => Promise<PlatformGatewaySuccess<import("./types").TopicListResponse>>>[0]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsListResponse>;
+        get(topicId: string): Promise<import("@/lucern/packages/client-core/src/topics").TopicsGetResponse>;
+        create(input: Parameters<(input: import("./topicsClient").TopicCreateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>>[0]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsCreateResponse>;
+        update(topicId: string, input: Parameters<(topicId: string, input: import("./topicsClient").TopicUpdateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>>[1]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsUpdateResponse>;
+        tree(topicId: string, query?: Parameters<(topicId: string, query?: import("./topicsClient").TopicTreeQuery) => Promise<PlatformGatewaySuccess<import("./types").TopicTreeResponse>>>[1]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsTreeResponse>;
+        getTree(input: {
+            rootId: string;
+            maxDepth?: number;
+        }): Promise<import("@/lucern/packages/client-core/src/topics").TopicsTreeResponse>;
+        coverage(topicId: string, query?: Parameters<(topicId: string, query?: import("./topicsClient").TopicCoverageQuery) => Promise<PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>>[1]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsCoverageResponse>;
+    };
+    answers: {
+        create(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<import("@/lucern/packages/client-core/src/questions").QuestionsAnswerResponse>;
+        get(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    };
+    contradictions: {
+        flag(args: {
+            beliefA: string;
+            beliefB: string;
+            description: string;
+            topicId?: string;
+            projectId?: string;
+            severity?: string;
+            defeatType?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/contradictions").ContradictionRecord>>;
+        list(args: {
+            topicId?: string;
+            projectId?: string;
+            status?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/contradictions").ContradictionListResult>>;
+        get(contradictionId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/contradictions").ContradictionRecord>>;
+        find: (args: {
+            topicId?: string;
+            projectId?: 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<import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyListResult>>;
+        get(ontologyId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyRecord>>;
+        bind(input: Parameters<(input: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").BindOntologyInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").BindOntologyInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[0], idempotencyKey?: Parameters<(input: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").BindOntologyInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").BindOntologyInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyBindingResult>>;
+        match(input: Parameters<(input: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[0], idempotencyKey?: Parameters<(input: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchResult>>;
+        create(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        update(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        archive(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        createVersion(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        publishVersion(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        deprecateVersion(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        resolveEffective(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        raw: {
+            list(filters?: import("./coreClient").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: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listDefinitions(filters?: import("./coreClient").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: import("./ontologyClient").OntologyDefinitionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateDefinition(id: string, input: import("./ontologyClient").OntologyDefinitionUpdateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            archiveDefinition(id: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listVersions(ontologyId: string, filters?: import("./coreClient").GatewayScope & {
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "versions">>>;
+            createVersion(ontologyId: string, input: import("./ontologyClient").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<import("./types").ListResult<any, "topics">>>;
+            listTopicsByOntology(ontologyId: string): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "topics">>>;
+        };
+    };
+    coordination: {
+        registerSession(input?: Parameters<(args?: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        heartbeatSession(input?: Parameters<(args?: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        endSession(input?: Parameters<(args?: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        listActiveSessions(input?: Parameters<(args?: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        sendAgentMessage(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        broadcastMessage(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        getInbox(input?: Parameters<(args?: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        claimFiles(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    policy: {
+        checkPermission(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<import("./policyClient").PermissionDecision>>;
+        listAccessibleTopics(input?: Parameters<(query?: import("./coreClient").GatewayScope & {
+            permission?: import("./policyClient").PermissionKind;
+            includeShared?: boolean;
+            principal?: string;
+            principalId?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                permission: import("./policyClient").PermissionKind;
+                topics: {
+                    [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: import("./policyClient").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: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<{
+            success: boolean;
+            data: {
+                permission: import("./policyClient").PermissionKind;
+                allowedTopicIds: string[];
+                deniedTopics: {
+                    topicId: string;
+                    reasonCode: string;
+                }[];
+                count: number;
+            };
+        }>;
+        manageWritePolicy(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        raw: {
+            listDecisions(query?: import("./coreClient").GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "decisions">>>;
+            grant(input: import("./coreClient").GatewayScope & {
+                topicId: string;
+                permission: import("./policyClient").PermissionKind;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+                expiresAt?: number;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revoke(input: import("./coreClient").GatewayScope & {
+                topicId: string;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listWritePolicies(query?: import("./coreClient").GatewayScope & {
+                topicId?: string;
+                role?: string;
+                toolCategory?: string;
+                enabled?: boolean;
+            }): Promise<{
+                data: {
+                    policies: import("./policyClient").WritePolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createWritePolicy(input: import("./policyClient").WritePolicyCreateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    created: boolean;
+                    policy: import("./policyClient").WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateWritePolicy(id: string, input: import("./policyClient").WritePolicyUpdateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    updated: boolean;
+                    policy: import("./policyClient").WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteWritePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                id?: string;
+                deleted?: boolean;
+            }>>;
+            checkPermission(query: import("./coreClient").GatewayScope & {
+                topicId?: string;
+                permission?: import("./policyClient").PermissionKind;
+                principal?: string;
+                principalId?: string;
+                beliefClusterId?: string;
+            }): Promise<PlatformGatewaySuccess<import("./policyClient").PermissionDecision>>;
+            listAccessibleTopics(query?: import("./coreClient").GatewayScope & {
+                permission?: import("./policyClient").PermissionKind;
+                includeShared?: boolean;
+                principal?: string;
+                principalId?: string;
+                limit?: number;
+            }): Promise<{
+                data: {
+                    permission: import("./policyClient").PermissionKind;
+                    topics: {
+                        [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: import("./coreClient").GatewayScope & {
+                topicIds?: string[];
+                permission?: import("./policyClient").PermissionKind;
+                principal?: string;
+                principalId?: string;
+            }): Promise<{
+                success: boolean;
+                data: {
+                    permission: import("./policyClient").PermissionKind;
+                    allowedTopicIds: string[];
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                    count: number;
+                };
+            }>;
+        };
+    };
+    observations: {
+        ingest(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        getContext(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    coding: {
+        getCodeContext(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        getChangeHistory(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        recordAttempt(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        getFailureLog(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    contracts: {
+        create(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        evaluate(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        getStatus(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    bootstrap: {
+        generateSessionHandoff(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    research: {
+        searchSources(args: {
+            query: string;
+            topicId?: string;
+            projectId?: string;
+            sources?: string[];
+        }): Promise<{
+            results: {
+                title: string;
+                url: string;
+                snippet: string;
+                relevanceScore: number;
+                suggestedEvidence: string;
+            }[];
+        }>;
+        executeDeepResearch(args: {
+            query: string;
+            topicId?: string;
+            projectId?: string;
+            depth?: "quick" | "standard" | "deep";
+        }): Promise<{
+            report: {
+                summary: string;
+                findings: {
+                    title: string;
+                    summary: string;
+                    sourceUrl: string;
+                }[];
+                sources: {
+                    title: string;
+                    url: string;
+                }[];
+                linkedEvidence: never[];
+                linkedQuestions: never[];
+            };
+        }>;
+    };
+    tools: {
+        register(registration: CustomToolRegistration): import("./customTools").RegisteredCustomTool;
+        unregister(fullName: string): boolean;
+        list(): import("./customTools").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<import("./types").ListResult<any, "catalog">>>;
+        catalog(): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
+        listStates(scope?: Parameters<(query?: import("./coreClient").GatewayScope) => Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>>[0]): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
+        states(scope?: Parameters<(query?: import("./coreClient").GatewayScope) => Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>>[0]): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
+        install(input: Parameters<(input: import("./packsClient").PackInstallInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        enable(input: Parameters<(input: import("./packsClient").PackEnableInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        disable(input: Parameters<(input: import("./packsClient").PackDisableInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    identity: {
+        whoami(): Promise<import("@/lucern/packages/client-core/src/identity").IdentityWhoamiResponse>;
+    };
+    custom: CustomToolNamespace;
+    extensions: Record<string, CustomToolNamespace>;
+    raw: {
+        beliefs: {
+            createBelief(input: import("./beliefsClient").CreateBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
+            modulateConfidence(beliefId: string, input: import("./beliefsClient").ModulateConfidenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").ModulateConfidenceResponse>>;
+            forkBelief(beliefId: string, input: import("./beliefsClient").ForkBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").ForkBeliefResponse>>;
+        };
+        graph: {
+            listNodes(query: import("./graphClient").ListNodesInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphNode, "nodes">>>;
+            queryNodes(query: import("./graphClient").QueryNodesInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphNode, "nodes">>>;
+            createNode(input: import("./graphClient").CreateNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            updateNode(input: import("./graphClient").UpdateNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            listEdges(query: import("./graphClient").ListEdgesInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphEdge, "edges">>>;
+            queryEdges(query: import("./graphClient").QueryEdgesInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphEdge, "edges">>>;
+            createEdge(input: import("./graphClient").CreateEdgeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphEdge>>;
+            deleteEdge(query: import("./graphClient").DeleteEdgeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").DeleteEdgeResponse>>;
+            neighborhood(query: import("./graphClient").NeighborhoodInput): Promise<PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>;
+            traverse(query: import("./graphClient").TraverseInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            analyze(query?: import("./graphClient").AnalyzeInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            bias(query?: import("./graphClient").BiasInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            gaps(query: import("./graphClient").GapsInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            search(query: import("./graphClient").SearchInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            getNeighborhood(query: import("./graphClient").NeighborhoodInput): Promise<PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>;
+            getPath(query: import("./graphClient").PathInput): Promise<PlatformGatewaySuccess<import("./types").GraphPathResponse>>;
+            getAnalytics(query?: import("./graphClient").AnalyticsInput): Promise<PlatformGatewaySuccess<import("./types").GraphAnalyticsResponse>>;
+        };
+        decisions: {
+            listJudgments(query: import("./decisionsClient").ListJudgmentsInput): Promise<PlatformGatewaySuccess<import("./types").ListJudgmentsResponse>>;
+            getJudgment(judgmentId: string): Promise<PlatformGatewaySuccess<import("./types").GetJudgmentResponse>>;
+            getJudgmentReadiness(query: {
+                topicId?: string;
+                projectId?: string;
+            } & import("./types").TopicIdentifierInput): Promise<PlatformGatewaySuccess<import("./types").JudgmentReadinessResponse>>;
+            getJudgmentCalibration(query: import("./decisionsClient").GetJudgmentCalibrationInput): Promise<PlatformGatewaySuccess<import("./types").JudgmentCalibrationResponse>>;
+            listPendingOutcomeReviews(query: import("./decisionsClient").ListPendingJudgmentOutcomeReviewInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").PendingJudgmentOutcomeRecord, "reviews">>>;
+            listPendingJudgmentOutcomeReview(query: import("./decisionsClient").ListPendingJudgmentOutcomeReviewInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").PendingJudgmentOutcomeRecord, "reviews">>>;
+            getJudgmentTransitionAuditIntegrity(query: import("./decisionsClient").GetJudgmentTransitionAuditIntegrityInput): Promise<PlatformGatewaySuccess<import("./types").JudgmentTransitionAuditIntegrityResponse>>;
+            createJudgment(input: RecordJudgmentInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
+            recordJudgment(input: RecordJudgmentInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").RecordJudgmentResponse>>;
+            updateJudgmentOutcome(judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
+            recordJudgmentOutcome(judgmentId: string, input: import("./decisionsClient").RecordJudgmentOutcomeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").RecordJudgmentOutcomeResponse>>;
+        };
+        workflow: {
+            listBranches(query: {
+                topicId?: string;
+                projectId?: string;
+                status?: import("./workflowClient").WorkflowBranchStatus;
+                limit?: number;
+            } & import("./types").TopicIdentifierInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowBranchRecord, "branches">>>;
+            createBranch(input: {
+                name: string;
+                topicId?: string;
+                projectId?: string;
+                description?: string;
+                metadata?: JsonObject;
+            } & import("./types").TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowBranchRecord>>;
+            listLenses(query: {
+                workspaceId?: string;
+                topicId?: string;
+                projectId?: string;
+                status?: import("./workflowClient").WorkflowLensStatus;
+                perspectiveType?: import("./workflowClient").WorkflowLensPerspectiveType;
+            } & import("./types").TopicIdentifierInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowLensRecord, "lenses">>>;
+            createLens(input: {
+                name: string;
+                workspaceId?: string;
+                topicId?: string;
+                projectId?: string;
+                description?: string;
+                perspectiveType: import("./workflowClient").WorkflowLensPerspectiveType;
+                promptTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensPromptTemplateReference[];
+                workflowTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensWorkflowTemplate[];
+                taskTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensTaskTemplate[];
+                filterCriteria?: JsonObject;
+            } & import("./types").TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowLensRecord>>;
+            applyLensToTopic(input: {
+                lensId: string;
+                topicId?: string;
+                projectId?: string;
+                metadata?: JsonObject;
+            } & import("./types").TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>;
+            removeLensFromTopic(input: {
+                lensId: string;
+                topicId?: string;
+                projectId?: string;
+            } & import("./types").TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>;
+            listWorktrees(query: {
+                topicId?: string;
+                projectId?: string;
+                branchId?: string;
+                status?: import("./workflowClient").WorkflowWorktreeStatus;
+                track?: string;
+                executionBand?: number;
+                limit?: number;
+            } & import("./types").TopicIdentifierInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowWorktreeRecord, "worktrees">>>;
+            listAllWorktrees(query?: {
+                status?: import("./workflowClient").WorkflowWorktreeStatus;
+                track?: string;
+                executionBand?: number;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListWorktreesResponse>>;
+            createWorktree(input: AddWorktreeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            addWorktree(input: AddWorktreeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            merge(worktreeId: string, input: MergeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").MergeWorktreeResponse>>;
+            activateWorktree(worktreeId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            updateWorktreeTargets(input: import("./workflowClient").UpdateWorktreeTargetsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            openPullRequest(worktreeId: string, input: {
+                summary: string;
+                reviewers?: string[];
+                status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").OpenPullRequestResponse>>;
+            push(worktreeId: string, input: {
+                targetContext: string;
+                beliefIds?: string[];
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").PushWorktreeResponse>>;
+            listTopics(query?: import("./workflowClient").ListTopicsInput): Promise<PlatformGatewaySuccess<import("./types").ListTopicsResponse>>;
+            switchTopicContext(input: import("./workflowClient").SwitchTopicContextInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").SwitchTopicContextResponse>>;
+            createTask(input: CreateTaskInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").CreateTaskResponse>>;
+            completeTask(taskId: string, input: CompleteTaskInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").CompleteTaskResponse>>;
+            updateTask(taskId: string, input: UpdateTaskInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").UpdateTaskResponse>>;
+            createPillar(input: {
+                name: string;
+                topicId?: string;
+                projectId?: string;
+                description?: string;
+                metadata?: JsonObject;
+            } & import("./types").TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowBranchRecord>>;
+            createSprint(input: {
+                title: string;
+                topicId?: string;
+                projectId?: string;
+                branchId?: string;
+                hypothesis?: string;
+                beliefIds?: string[];
+            } & import("./types").TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            completeSprint(worktreeId: string, input: MergeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").MergeWorktreeResponse>>;
+            requestReview(worktreeId: string, input: {
+                summary: string;
+                reviewers?: string[];
+                status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").OpenPullRequestResponse>>;
+            publishFindings(worktreeId: string, input: {
+                targetContext: string;
+                beliefIds?: string[];
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").PushWorktreeResponse>>;
+        };
+        audit: {
+            listEvents(query?: import("./coreClient").GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
+                projectId?: string;
+                limit?: number;
+            } & import("./types").TopicIdentifierInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "events">>>;
+        };
+        admin: {
+            listTenants(query?: {
+                status?: "active" | "disabled" | "archived";
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "tenants">>>;
+            createTenant(input: {
+                key: string;
+                slug?: string;
+                name: string;
+                status?: "active" | "disabled" | "archived";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getControlObjectOwnership(): Promise<PlatformGatewaySuccess<import("./controlObjectOwnership").ControlObjectOwnershipContract>>;
+            getControlObjectOwnershipContract(): Promise<PlatformGatewaySuccess<import("./controlObjectOwnership").ControlObjectOwnershipContract>>;
+            listWorkspaces(query?: import("./coreClient").GatewayScope & {
+                status?: "active" | "archived";
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "workspaces">>>;
+            createWorkspace(input: import("./coreClient").GatewayScope & {
+                key: string;
+                slug?: string;
+                name: string;
+                status?: "active" | "archived";
+                defaultProjectVisibility?: "private" | "firm" | "public";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listMemberships(query?: import("./coreClient").GatewayScope & {
+                principalId?: string;
+                status?: "active" | "revoked" | "expired";
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "memberships">>>;
+            createMembership(input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                role: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                status?: "active" | "revoked" | "expired";
+                source?: "bootstrap" | "manual" | "sync" | "invitation";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateMembership(input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                role: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                status?: "active" | "revoked" | "expired";
+                source?: "bootstrap" | "manual" | "sync" | "invitation";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertMembership(input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                role: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                status?: "active" | "revoked" | "expired";
+                source?: "bootstrap" | "manual" | "sync" | "invitation";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        identity: {
+            whoami(): Promise<import("@/lucern/packages/client-core/src/identity").IdentityWhoamiResponse>;
+            listPrincipals(query?: import("./coreClient").GatewayScope & {
+                status?: string;
+                principalType?: string;
+                query?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "principals">>>;
+            createPrincipal(input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                principalType: "user" | "group" | "service" | "external_viewer";
+                clerkId?: string;
+                email?: string;
+                displayName?: string;
+                status?: "active" | "disabled" | "revoked";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updatePrincipal(input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                principalType: "user" | "group" | "service" | "external_viewer";
+                clerkId?: string;
+                email?: string;
+                displayName?: string;
+                status?: "active" | "disabled" | "revoked";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertPrincipal(input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                principalType: "user" | "group" | "service" | "external_viewer";
+                clerkId?: string;
+                email?: string;
+                displayName?: string;
+                status?: "active" | "disabled" | "revoked";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listKeys(query?: import("./coreClient").GatewayScope & {
+                principalId?: string;
+                status?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "keys">>>;
+            createKey(input: import("./coreClient").GatewayScope & {
+                principalId: string;
+                keyId?: string;
+                token?: string;
+                scopes?: string[];
+                environment?: "sandbox" | "production";
+                expiresInDays?: number;
+                rateLimitTier?: "free" | "developer" | "partner";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<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>>;
+        };
+        policy: {
+            listDecisions(query?: import("./coreClient").GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "decisions">>>;
+            grant(input: import("./coreClient").GatewayScope & {
+                topicId: string;
+                permission: import("./policyClient").PermissionKind;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+                expiresAt?: number;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revoke(input: import("./coreClient").GatewayScope & {
+                topicId: string;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listWritePolicies(query?: import("./coreClient").GatewayScope & {
+                topicId?: string;
+                role?: string;
+                toolCategory?: string;
+                enabled?: boolean;
+            }): Promise<{
+                data: {
+                    policies: import("./policyClient").WritePolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createWritePolicy(input: import("./policyClient").WritePolicyCreateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    created: boolean;
+                    policy: import("./policyClient").WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateWritePolicy(id: string, input: import("./policyClient").WritePolicyUpdateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    updated: boolean;
+                    policy: import("./policyClient").WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteWritePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                id?: string;
+                deleted?: boolean;
+            }>>;
+            checkPermission(query: import("./coreClient").GatewayScope & {
+                topicId?: string;
+                permission?: import("./policyClient").PermissionKind;
+                principal?: string;
+                principalId?: string;
+                beliefClusterId?: string;
+            }): Promise<PlatformGatewaySuccess<import("./policyClient").PermissionDecision>>;
+            listAccessibleTopics(query?: import("./coreClient").GatewayScope & {
+                permission?: import("./policyClient").PermissionKind;
+                includeShared?: boolean;
+                principal?: string;
+                principalId?: string;
+                limit?: number;
+            }): Promise<{
+                data: {
+                    permission: import("./policyClient").PermissionKind;
+                    topics: {
+                        [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: import("./coreClient").GatewayScope & {
+                topicIds?: string[];
+                permission?: import("./policyClient").PermissionKind;
+                principal?: string;
+                principalId?: string;
+            }): Promise<{
+                success: boolean;
+                data: {
+                    permission: import("./policyClient").PermissionKind;
+                    allowedTopicIds: string[];
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                    count: number;
+                };
+            }>;
+        };
+        answers: {
+            get(questionId: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+        ontology: {
+            list(filters?: import("./coreClient").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: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listDefinitions(filters?: import("./coreClient").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: import("./ontologyClient").OntologyDefinitionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateDefinition(id: string, input: import("./ontologyClient").OntologyDefinitionUpdateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            archiveDefinition(id: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listVersions(ontologyId: string, filters?: import("./coreClient").GatewayScope & {
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "versions">>>;
+            createVersion(ontologyId: string, input: import("./ontologyClient").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<import("./types").ListResult<any, "topics">>>;
+            listTopicsByOntology(ontologyId: string): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "topics">>>;
+        };
+        mcpParity: {
+            sessionId: `${string}-${string}-${string}-${string}-${string}`;
+            listTopics(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            createTopic(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getTopic(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            getTopicTree(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            activateWorktree(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateWorktreeMetadata(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateWorktreeTargets(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listAllWorktrees(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            pipelineSnapshot(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            recordScopeLearning(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            discover(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            analyzeTopicDensity(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            applyAutoBranching(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            seedBeliefLattice(args?: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getLatticeCoverage(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            matchEntityType(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            discoverEntityConnections(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            triggerBeliefReview(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listOntologies(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            getOntology(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            applyOntology(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            createOntology(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateOntology(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            archiveOntology(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            createOntologyVersion(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            publishOntologyVersion(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deprecateOntologyVersion(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            resolveEffectiveOntology(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            registerSession(args?: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            heartbeatSession(args?: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            endSession(args?: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listActiveSessions(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            sendAgentMessage(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            broadcastMessage(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getAgentInbox(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            claimFiles(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTasks(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            createAnswer(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getAnswer(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            flagContradiction(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            ingestObservation(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getObservationContext(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            getCodeContext(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            getChangeHistory(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            recordAttempt(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getFailureLog(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            createEpistemicContract(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            evaluateContract(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getContractStatus(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            checkPermission(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            filterByPermission(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            manageWritePolicy(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            generateSessionHandoff(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        packs: {
+            listCatalog(): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
+            getCatalog(): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
+            listStates(query?: import("./coreClient").GatewayScope): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
+            getStates(query?: import("./coreClient").GatewayScope): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
+            getHealth(packKey: string, query?: import("./coreClient").GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            listTelemetry(query?: import("./coreClient").GatewayScope & {
+                lookbackHours?: number;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "telemetry">>>;
+            getTelemetry(query?: import("./coreClient").GatewayScope & {
+                lookbackHours?: number;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "telemetry">>>;
+            createEntitlement(input: import("./packsClient").PackEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateEntitlement(input: import("./packsClient").PackEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertEntitlement(input: import("./packsClient").PackEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            install(input: import("./packsClient").PackInstallInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            enable(input: import("./packsClient").PackEnableInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            disable(input: import("./packsClient").PackDisableInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upgrade(input: import("./packsClient").PackUpgradeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        reports: {
+            listTemplates(args?: {
+                slug?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ReportTemplatesResponse>>;
+            getTemplates(args?: {
+                slug?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ReportTemplatesResponse>>;
+            listReports(input: import("./types").TopicIdentifierInput, args?: {
+                summary?: boolean;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "reports">>>;
+            getReport(reportId: string): Promise<PlatformGatewaySuccess<import("./types").ReportWithSectionsResponse>>;
+        };
+        learning: {
+            listRecentExecutions(args?: {
+                namespace?: string;
+                topicId?: string;
+                projectId?: string;
+                audienceMode?: string;
+                success?: boolean;
+                limit?: number;
+            } & import("./types").TopicIdentifierInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "executions">>>;
+            getRecentExecutions(args?: {
+                namespace?: string;
+                topicId?: string;
+                projectId?: string;
+                audienceMode?: string;
+                success?: boolean;
+                limit?: number;
+            } & import("./types").TopicIdentifierInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "executions">>>;
+            getExecutionStats(args?: {
+                namespace?: string;
+                topicId?: string;
+                projectId?: string;
+                audienceMode?: string;
+                hours?: number;
+            } & import("./types").TopicIdentifierInput): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        harness: {
+            listAgentDefinitions(scope?: import("./coreClient").GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "agents">>>;
+            getAgentDefinition(agentId: string, scope?: import("./coreClient").GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            createAgentDefinition(input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            registerAgentDefinition(input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateAgentDefinition(agentId: string, input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listAgentRuns(agentId: string, scope?: import("./coreClient").GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
+            listRunsForAgent(agentId: string, scope?: import("./coreClient").GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
+            listToolDefinitions(scope?: import("./coreClient").GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+                gateClassification?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "tools">>>;
+            getToolDefinition(toolId: string, scope?: import("./coreClient").GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            createToolDefinition(input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            registerToolDefinition(input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateToolDefinition(toolId: string, input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listRunEntries(scope?: import("./coreClient").GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
+            listRunLedgerEntries(scope?: import("./coreClient").GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "runs">>>;
+            startHarnessRun(input: import("./harnessClient").HarnessStartRunInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getRunLedgerEntry(runId: string): Promise<PlatformGatewaySuccess<unknown>>;
+            reportHarnessRunEvent(runId: string, input: import("./harnessClient").HarnessRunReportInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            heartbeatHarnessRun(runId: string, input: {
+                reportingToken: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            completeHarnessRun(runId: string, input: import("./harnessClient").HarnessCompleteRunInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listPromptResolutions(query?: {
+                runId?: string;
+                promptName?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "prompts">>>;
+            getScopeTaxonomy(): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        schema: {
+            listPacks(scope?: import("./coreClient").GatewayScope): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "packs">>>;
+            installPack(input: import("./schemaClient").SchemaPackInstallInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getPack(packId: string, scope?: import("./coreClient").GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            listEntitlements(scope?: import("./coreClient").GatewayScope & {
+                packKey?: string;
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "entitlements">>>;
+            createEntitlement(input: import("./schemaClient").SchemaEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateEntitlement(input: import("./schemaClient").SchemaEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertEntitlement(input: import("./schemaClient").SchemaEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        audiences: {
+            listRegistry(query?: import("./coreClient").GatewayScope & {
+                effective?: boolean;
+                status?: "active" | "disabled" | "archived";
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "registryEntries">>>;
+            getRegistry(query?: import("./coreClient").GatewayScope & {
+                effective?: boolean;
+                status?: "active" | "disabled" | "archived";
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "registryEntries">>>;
+            createRegistryEntry(input: import("./audiencesClient").AudienceRegistryInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateRegistryEntry(input: import("./audiencesClient").AudienceRegistryInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertRegistry(input: import("./audiencesClient").AudienceRegistryInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listGrants(query?: import("./coreClient").GatewayScope & {
+                audienceKey?: string;
+                principalId?: string;
+                groupId?: string;
+                status?: "active" | "revoked" | "expired";
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "grants">>>;
+            getGrants(query?: import("./coreClient").GatewayScope & {
+                audienceKey?: string;
+                principalId?: string;
+                groupId?: string;
+                status?: "active" | "revoked" | "expired";
+            }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "grants">>>;
+            createGrant(input: import("./audiencesClient").AudienceGrantInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            grant(input: import("./audiencesClient").AudienceGrantInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deleteGrant(input: import("./audiencesClient").AudienceGrantRevokeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revokeGrant(input: import("./audiencesClient").AudienceGrantRevokeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        topics: {
+            list(query?: import("./topicsClient").TopicListInput): Promise<PlatformGatewaySuccess<import("./types").TopicListResponse>>;
+            get(topicId: string): Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>;
+            create(input: import("./topicsClient").TopicCreateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>;
+            update(topicId: string, input: import("./topicsClient").TopicUpdateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>;
+            getTree(topicId: string, query?: import("./topicsClient").TopicTreeQuery): Promise<PlatformGatewaySuccess<import("./types").TopicTreeResponse>>;
+            getCoverage(topicId: string, query?: import("./topicsClient").TopicCoverageQuery): Promise<PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>;
+        };
+    };
+};
+export {};