@lucern/sdk 0.2.0-alpha.10 → 0.2.0-alpha.11

package/dist/audience/index.d.ts

@@ -0,0 +1,38 @@
+type AudienceMode = "internal" | "lp" | "public";
+type AudienceClass = "internal" | "restricted_external" | "public";
+type ResolvedAudience = {
+    audienceKey: string;
+    audienceClass: AudienceClass;
+    audienceMode: AudienceMode;
+};
+type AllowedAudienceScope = {
+    allowedAudienceClasses: AudienceClass[];
+    allowedAudienceKeys: string[];
+    allowedAudienceModes: AudienceMode[];
+};
+type PrincipalAudienceScope = {
+    mode: "legacy_open" | "grant_enforced" | "admin_override";
+    grantModelEnabled: boolean;
+    grantedAudienceKeys: string[];
+    grantedAudienceClasses: AudienceClass[];
+    allowedAudienceKeys: string[];
+    allowedAudienceClasses: AudienceClass[];
+    allowedAudienceModes: AudienceMode[];
+};
+declare const AUDIENCE_CLASS_RANK: Record<AudienceClass, number>;
+declare function normalizeAudienceKey(key: string | undefined | null): string;
+declare function normalizeAudienceMode(mode: string | undefined | null): AudienceMode;
+declare function classFromAudienceMode(mode: AudienceMode): AudienceClass;
+declare function modeFromAudienceClass(audienceClass: AudienceClass): AudienceMode;
+declare function classFromAudienceKey(audienceKey: string | undefined | null, fallback?: AudienceClass): AudienceClass;
+declare function resolveAudience(args?: {
+    audienceMode?: string | null;
+    audienceKey?: string | null;
+    audienceClass?: AudienceClass | null;
+}): ResolvedAudience;
+declare function canViewAudienceLabel(viewerAudience: string, resourceAudienceLabel: string | undefined | null): boolean;
+declare function canAudienceClassAccess(viewerClass: AudienceClass, resourceClass: AudienceClass): boolean;
+declare function deriveAllowedAudienceClasses(visibility: string | undefined | null): AudienceClass[];
+declare function intersectAudienceScopes(visibilityScope: AllowedAudienceScope, principalScope: PrincipalAudienceScope): AllowedAudienceScope;
+
+export { AUDIENCE_CLASS_RANK, type AllowedAudienceScope, type AudienceClass, type AudienceMode, type PrincipalAudienceScope, type ResolvedAudience, canAudienceClassAccess, canViewAudienceLabel, classFromAudienceKey, classFromAudienceMode, deriveAllowedAudienceClasses, intersectAudienceScopes, modeFromAudienceClass, normalizeAudienceKey, normalizeAudienceMode, resolveAudience };

package/dist/audience/index.js

@@ -0,0 +1,110 @@
+// src/audience/index.ts
+var AUDIENCE_CLASS_RANK = {
+  public: 0,
+  restricted_external: 1,
+  internal: 2
+};
+function normalizeKey(key) {
+  return (key ?? "").trim().toLowerCase().replace(/[^a-z0-9:_-]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function normalizeAudienceKey(key) {
+  return normalizeKey(key);
+}
+function normalizeAudienceMode(mode) {
+  if (mode === "public" || mode === "lp" || mode === "internal") {
+    return mode;
+  }
+  return "internal";
+}
+function classFromAudienceMode(mode) {
+  if (mode === "public") {
+    return "public";
+  }
+  if (mode === "lp") {
+    return "restricted_external";
+  }
+  return "internal";
+}
+function modeFromAudienceClass(audienceClass) {
+  if (audienceClass === "public") {
+    return "public";
+  }
+  if (audienceClass === "restricted_external") {
+    return "lp";
+  }
+  return "internal";
+}
+function classFromAudienceKey(audienceKey, fallback = "internal") {
+  const key = normalizeKey(audienceKey);
+  if (!key) {
+    return fallback;
+  }
+  if (key === "internal") {
+    return "internal";
+  }
+  if (key === "public") {
+    return "public";
+  }
+  if (key === "lp" || key === "external" || key === "client" || key === "partner" || key === "portfolio" || key === "network" || key === "restricted_external") {
+    return "restricted_external";
+  }
+  return fallback;
+}
+function resolveAudience(args) {
+  const fallbackMode = normalizeAudienceMode(args?.audienceMode);
+  const fallbackKey = normalizeKey(args?.audienceKey) || fallbackMode;
+  const fallbackClass = args?.audienceClass ?? classFromAudienceKey(fallbackKey);
+  return {
+    audienceKey: fallbackKey,
+    audienceClass: fallbackClass,
+    audienceMode: modeFromAudienceClass(fallbackClass)
+  };
+}
+function canViewAudienceLabel(viewerAudience, resourceAudienceLabel) {
+  const viewerClass = classFromAudienceKey(viewerAudience, "public");
+  const resourceClass = classFromAudienceKey(resourceAudienceLabel, "internal");
+  return canAudienceClassAccess(viewerClass, resourceClass);
+}
+function canAudienceClassAccess(viewerClass, resourceClass) {
+  return AUDIENCE_CLASS_RANK[viewerClass] >= AUDIENCE_CLASS_RANK[resourceClass];
+}
+function deriveAllowedAudienceClasses(visibility) {
+  if (visibility === "public") {
+    return ["internal", "restricted_external", "public"];
+  }
+  if (visibility === "firm" || visibility === "external") {
+    return ["internal", "restricted_external"];
+  }
+  return ["internal"];
+}
+function unique(items) {
+  return [...new Set(items)];
+}
+function intersect(left, right) {
+  const rightSet = new Set(right);
+  return left.filter((entry) => rightSet.has(entry));
+}
+function intersectAudienceScopes(visibilityScope, principalScope) {
+  const allowedAudienceClasses = intersect(
+    visibilityScope.allowedAudienceClasses,
+    principalScope.allowedAudienceClasses
+  );
+  const allowedAudienceKeys = intersect(
+    visibilityScope.allowedAudienceKeys.map(
+      (entry) => normalizeAudienceKey(entry)
+    ),
+    principalScope.allowedAudienceKeys.map((entry) => normalizeAudienceKey(entry))
+  ).filter(Boolean);
+  const mergedClasses = unique(allowedAudienceClasses);
+  return {
+    allowedAudienceClasses: mergedClasses,
+    allowedAudienceKeys: unique(allowedAudienceKeys),
+    allowedAudienceModes: unique(
+      mergedClasses.map((audienceClass) => modeFromAudienceClass(audienceClass))
+    )
+  };
+}
+
+export { AUDIENCE_CLASS_RANK, canAudienceClassAccess, canViewAudienceLabel, classFromAudienceKey, classFromAudienceMode, deriveAllowedAudienceClasses, intersectAudienceScopes, modeFromAudienceClass, normalizeAudienceKey, normalizeAudienceMode, resolveAudience };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/audience/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/audience/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["export type AudienceMode = \"internal\" | \"lp\" | \"public\";\nexport type AudienceClass = \"internal\" | \"restricted_external\" | \"public\";\n\nexport type ResolvedAudience = {\n  audienceKey: string;\n  audienceClass: AudienceClass;\n  audienceMode: AudienceMode;\n};\n\nexport type AllowedAudienceScope = {\n  allowedAudienceClasses: AudienceClass[];\n  allowedAudienceKeys: string[];\n  allowedAudienceModes: AudienceMode[];\n};\n\nexport type PrincipalAudienceScope = {\n  mode: \"legacy_open\" | \"grant_enforced\" | \"admin_override\";\n  grantModelEnabled: boolean;\n  grantedAudienceKeys: string[];\n  grantedAudienceClasses: AudienceClass[];\n  allowedAudienceKeys: string[];\n  allowedAudienceClasses: AudienceClass[];\n  allowedAudienceModes: AudienceMode[];\n};\n\nexport const AUDIENCE_CLASS_RANK: Record<AudienceClass, number> = {\n  public: 0,\n  restricted_external: 1,\n  internal: 2,\n};\n\nfunction normalizeKey(key: string | undefined | null): string {\n  return (key ?? \"\")\n    .trim()\n    .toLowerCase()\n    .replace(/[^a-z0-9:_-]+/g, \"_\")\n    .replace(/_+/g, \"_\")\n    .replace(/^_+|_+$/g, \"\");\n}\n\nexport function normalizeAudienceKey(key: string | undefined | null): string {\n  return normalizeKey(key);\n}\n\nexport function normalizeAudienceMode(\n  mode: string | undefined | null\n): AudienceMode {\n  if (mode === \"public\" || mode === \"lp\" || mode === \"internal\") {\n    return mode;\n  }\n  return \"internal\";\n}\n\nexport function classFromAudienceMode(mode: AudienceMode): AudienceClass {\n  if (mode === \"public\") {\n    return \"public\";\n  }\n  if (mode === \"lp\") {\n    return \"restricted_external\";\n  }\n  return \"internal\";\n}\n\nexport function modeFromAudienceClass(\n  audienceClass: AudienceClass\n): AudienceMode {\n  if (audienceClass === \"public\") {\n    return \"public\";\n  }\n  if (audienceClass === \"restricted_external\") {\n    return \"lp\";\n  }\n  return \"internal\";\n}\n\nexport function classFromAudienceKey(\n  audienceKey: string | undefined | null,\n  fallback: AudienceClass = \"internal\"\n): AudienceClass {\n  const key = normalizeKey(audienceKey);\n  if (!key) {\n    return fallback;\n  }\n  if (key === \"internal\") {\n    return \"internal\";\n  }\n  if (key === \"public\") {\n    return \"public\";\n  }\n  if (\n    key === \"lp\" ||\n    key === \"external\" ||\n    key === \"client\" ||\n    key === \"partner\" ||\n    key === \"portfolio\" ||\n    key === \"network\" ||\n    key === \"restricted_external\"\n  ) {\n    return \"restricted_external\";\n  }\n  return fallback;\n}\n\nexport function resolveAudience(args?: {\n  audienceMode?: string | null;\n  audienceKey?: string | null;\n  audienceClass?: AudienceClass | null;\n}): ResolvedAudience {\n  const fallbackMode = normalizeAudienceMode(args?.audienceMode);\n  const fallbackKey = normalizeKey(args?.audienceKey) || fallbackMode;\n  const fallbackClass =\n    args?.audienceClass ?? classFromAudienceKey(fallbackKey);\n\n  return {\n    audienceKey: fallbackKey,\n    audienceClass: fallbackClass,\n    audienceMode: modeFromAudienceClass(fallbackClass),\n  };\n}\n\nexport function canViewAudienceLabel(\n  viewerAudience: string,\n  resourceAudienceLabel: string | undefined | null\n): boolean {\n  const viewerClass = classFromAudienceKey(viewerAudience, \"public\");\n  const resourceClass = classFromAudienceKey(resourceAudienceLabel, \"internal\");\n  return canAudienceClassAccess(viewerClass, resourceClass);\n}\n\nexport function canAudienceClassAccess(\n  viewerClass: AudienceClass,\n  resourceClass: AudienceClass\n): boolean {\n  return AUDIENCE_CLASS_RANK[viewerClass] >= AUDIENCE_CLASS_RANK[resourceClass];\n}\n\nexport function deriveAllowedAudienceClasses(\n  visibility: string | undefined | null\n): AudienceClass[] {\n  if (visibility === \"public\") {\n    return [\"internal\", \"restricted_external\", \"public\"];\n  }\n  if (visibility === \"firm\" || visibility === \"external\") {\n    return [\"internal\", \"restricted_external\"];\n  }\n  return [\"internal\"];\n}\n\nfunction unique<T>(items: T[]): T[] {\n  return [...new Set(items)];\n}\n\nfunction intersect<T>(left: T[], right: T[]): T[] {\n  const rightSet = new Set(right);\n  return left.filter((entry) => rightSet.has(entry));\n}\n\nexport function intersectAudienceScopes(\n  visibilityScope: AllowedAudienceScope,\n  principalScope: PrincipalAudienceScope\n): AllowedAudienceScope {\n  const allowedAudienceClasses = intersect(\n    visibilityScope.allowedAudienceClasses,\n    principalScope.allowedAudienceClasses\n  );\n  const allowedAudienceKeys = intersect(\n    visibilityScope.allowedAudienceKeys.map((entry) =>\n      normalizeAudienceKey(entry)\n    ),\n    principalScope.allowedAudienceKeys.map((entry) => normalizeAudienceKey(entry))\n  ).filter(Boolean);\n  const mergedClasses = unique(allowedAudienceClasses);\n  return {\n    allowedAudienceClasses: mergedClasses,\n    allowedAudienceKeys: unique(allowedAudienceKeys),\n    allowedAudienceModes: unique(\n      mergedClasses.map((audienceClass) => modeFromAudienceClass(audienceClass))\n    ),\n  };\n}\n"]}

package/dist/beliefs/index.d.ts

@@ -0,0 +1,465 @@
+import { ModulateConfidenceInput, OpinionHistoryEntry } from '../beliefsClient.js';
+import { PlatformGatewaySuccess } from '../coreClient.js';
+import { JsonObject } from '../types.js';
+import { LucernClientConfig } from '../client.js';
+import * as v1 from '@lucern/contracts/beliefs/v1';
+export { v1 as beliefsContracts };
+import * as mcpTools_contract from '@lucern/contracts/mcp-tools.contract';
+export { mcpTools_contract as toolSchemas };
+import * as sdkMethods_contract from '@lucern/contracts/sdk-methods.contract';
+export { sdkMethods_contract as methodSchemas };
+import '../opinion.js';
+import '../contracts/workflow-runtime.contract.js';
+import '../contracts/lens-workflow.contract.js';
+import '../contracts/lens-filter.contract.js';
+import '../audiencesClient.js';
+import '../schemaClient.js';
+import '../harnessClient.js';
+import '../identityClient.js';
+import '../adminClient.js';
+import '../controlObjectOwnership.js';
+import '../packsClient.js';
+import '../customTools.js';
+import 'zod';
+import '../mcpTools-DPZxowDX.js';
+import '../policyClient.js';
+import '../ontologyClient.js';
+import '../contextTypes.js';
+import '../topicsClient.js';
+import '../answersClient.js';
+import '../auditClient.js';
+import '../contextClient.js';
+import '../decisionsClient.js';
+import '../evidenceClient.js';
+import '../graphClient.js';
+import '../learningClient.js';
+import '../mcpParityClient.js';
+import '../reportsClient.js';
+import '../sourcesClient.js';
+import '../workflowClient.js';
+
+type BeliefsClientConfig = LucernClientConfig;
+type BeliefsClient = ReturnType<typeof createBeliefsClient>;
+declare function createBeliefsClient(config?: BeliefsClientConfig): {
+    createBelief: (input: {
+        topicId?: string;
+        text?: string;
+        canonicalText?: string;
+        formulation?: string;
+        rationale?: string;
+        worktreeId?: string;
+        pillar?: string;
+        baseRate: number;
+        sourceBeliefIds?: string[];
+        sourceType?: string;
+        beliefType?: string;
+        reversibility?: string;
+        predictionMeta?: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<PlatformGatewaySuccess<{
+        [x: string]: unknown;
+    } & {
+        id?: string;
+        beliefId?: string;
+        nodeId?: string;
+    }> & {
+        [x: string]: unknown;
+    } & {
+        id?: string;
+        beliefId?: string;
+        nodeId?: string;
+    }>;
+    getBelief: (nodeId: string) => Promise<PlatformGatewaySuccess<{
+        [x: string]: unknown;
+    } & {
+        id?: string;
+        beliefId?: string;
+        nodeId?: string;
+    }> & {
+        [x: string]: unknown;
+    } & {
+        id?: string;
+        beliefId?: string;
+        nodeId?: string;
+    }>;
+    listBeliefs: (args: {
+        topicId?: string;
+        worktreeId?: string;
+        status?: string;
+        minConfidence?: number;
+        limit?: number;
+        cursor?: string;
+    }) => Promise<PlatformGatewaySuccess<{
+        [x: string]: unknown;
+    } & {
+        cursor?: string;
+        total?: number;
+    } & {
+        beliefs?: ({
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        })[];
+    }> & {
+        [x: string]: unknown;
+    } & {
+        cursor?: string;
+        total?: number;
+    } & {
+        beliefs?: ({
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        })[];
+    }>;
+    searchBeliefs: (args: {
+        query: string;
+        topicId?: string;
+        status?: string;
+        minConfidence?: number;
+        limit?: number;
+    }) => Promise<{
+        results: Record<string, unknown>[];
+    }>;
+    refineBelief: (nodeId: string, textOrInput: string | {
+        text: string;
+        rationale?: string;
+    }, rationale?: string) => Promise<PlatformGatewaySuccess<{
+        [x: string]: unknown;
+    } & {
+        id?: string;
+        beliefId?: string;
+        nodeId?: string;
+    }> & {
+        [x: string]: unknown;
+    } & {
+        id?: string;
+        beliefId?: string;
+        nodeId?: string;
+    }>;
+    forkBelief: (nodeId: string, input: {
+        text?: string;
+        newFormulation?: string;
+        formulation?: string;
+        forkReason?: "refinement" | "contradiction_response" | "scope_change" | "confidence_collapse" | "manual";
+        rationale?: string;
+    }) => Promise<PlatformGatewaySuccess<{
+        [x: string]: unknown;
+    } & {
+        id?: string;
+        beliefId?: string;
+        nodeId?: string;
+    }> & {
+        [x: string]: unknown;
+    } & {
+        id?: string;
+        beliefId?: string;
+        nodeId?: string;
+    }>;
+    modulateBeliefConfidence: (nodeId: string, input: ModulateConfidenceInput) => Promise<PlatformGatewaySuccess<{
+        [x: string]: unknown;
+    }> & {
+        [x: string]: unknown;
+    }>;
+    archiveBelief: (nodeId: string, input?: string | {
+        reason?: string;
+        rationale?: string;
+    }) => Promise<PlatformGatewaySuccess<{
+        [x: string]: unknown;
+    }> & {
+        [x: string]: unknown;
+    }>;
+    getBeliefLineage: (nodeId: string) => Promise<PlatformGatewaySuccess<{
+        [x: string]: unknown;
+    } & {
+        beliefId?: string;
+        lineage?: {
+            [x: string]: unknown;
+        }[];
+    }> & {
+        [x: string]: unknown;
+    } & {
+        beliefId?: string;
+        lineage?: {
+            [x: string]: unknown;
+        }[];
+    }>;
+    getBeliefConfidenceHistory: (nodeId: string) => Promise<PlatformGatewaySuccess<{
+        [x: string]: unknown;
+    }> & {
+        [x: string]: unknown;
+    }>;
+    raw: {
+        create(input: {
+            topicId?: string;
+            text?: string;
+            canonicalText?: string;
+            formulation?: string;
+            rationale?: string;
+            worktreeId?: string;
+            pillar?: string;
+            baseRate: number;
+            sourceBeliefIds?: string[];
+            sourceType?: string;
+            beliefType?: string;
+            reversibility?: string;
+            predictionMeta?: JsonObject;
+            metadata?: JsonObject;
+        }): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }> & {
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>;
+        get(nodeId: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }> & {
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>;
+        refine(nodeId: string, textOrInput: string | {
+            text: string;
+            rationale?: string;
+        }, rationale?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }> & {
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>;
+        updateConfidence(nodeId: string, input: ModulateConfidenceInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        modulateConfidence(nodeId: string, input: ModulateConfidenceInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        updateStatus(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            status: "active" | "superseded" | "archived";
+            reason?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        updateRationale(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            rationale?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        linkBeliefs(input: Parameters<(input: {
+            fromNodeId: string;
+            toNodeId: string;
+            edgeType: string;
+            weight?: number;
+            context?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        unlinkEvidence(input: Parameters<(input: {
+            beliefNodeId?: string;
+            beliefId?: string;
+            insightId?: string;
+            evidenceId?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        updateCriticality(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            criticality: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        batchUpdateCriticality(input: Parameters<(input: {
+            updates: {
+                [x: string]: unknown;
+            }[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        reassignTopic(input: Parameters<(input: {
+            beliefNodeIds?: string[];
+            beliefIds?: string[];
+            targetTopicId: string;
+            reason?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        fork(nodeId: string, input: {
+            text?: string;
+            newFormulation?: string;
+            formulation?: string;
+            forkReason?: "refinement" | "contradiction_response" | "scope_change" | "confidence_collapse" | "manual";
+            rationale?: string;
+        }): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }> & {
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>;
+        archive(nodeId: string, input?: string | {
+            reason?: string;
+            rationale?: string;
+        }): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        list(args: {
+            topicId?: string;
+            worktreeId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+            cursor?: string;
+        }): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            beliefs?: ({
+                [x: string]: unknown;
+            } & {
+                id?: string;
+                beliefId?: string;
+                nodeId?: string;
+            })[];
+        }> & {
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            beliefs?: ({
+                [x: string]: unknown;
+            } & {
+                id?: string;
+                beliefId?: string;
+                nodeId?: string;
+            })[];
+        }>;
+        search: (args: {
+            query: string;
+            topicId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+        }) => Promise<{
+            results: Record<string, unknown>[];
+        }>;
+        lineage(nodeId: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            beliefId?: string;
+            lineage?: {
+                [x: string]: unknown;
+            }[];
+        }> & {
+            [x: string]: unknown;
+        } & {
+            beliefId?: string;
+            lineage?: {
+                [x: string]: unknown;
+            }[];
+        }>;
+        confidenceHistory(nodeId: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        opinionHistory(nodeId: string): Promise<OpinionHistoryEntry[]>;
+        createContract(nodeId: string, input: Parameters<(id: string, input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+        bisect(nodeId: string, input: Parameters<(id: string, input: {
+            expectedDirection: "overconfident" | "underconfident";
+            timeRange?: {
+                start: number;
+                end: number;
+            };
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }> & {
+            [x: string]: unknown;
+        }>;
+    };
+};
+
+export { type BeliefsClient, type BeliefsClientConfig, createBeliefsClient };