@lucern/sdk 1.0.11 → 1.0.13

package/dist/boundaryClientSurface.d.ts

@@ -1,20 +1,15 @@
-import { JsonObject, ListResult } from './types.js';
-import './contracts/workflow-runtime.contract.js';
-import './contracts/lens-workflow.contract.js';
-import './contracts/lens-filter.contract.js';
-
-type TopicProjectAliasInput = {
+import type { JsonObject, ListResult } from "./types";
+export type TopicProjectAliasInput = {
     topicId?: string;
     /** @deprecated Use topicId. */
     projectId?: string;
 };
-declare function cleanOptionalString(value: string | undefined): string | undefined;
-declare function cleanRequiredString(value: string | undefined, label: string): string;
-declare function readTopicId(input: TopicProjectAliasInput): string | undefined;
-declare function requireTopicId(input: TopicProjectAliasInput): string;
-declare function assertKnownKeys<T extends string>(input: Record<string, unknown>, allowed: readonly T[], operation: string): void;
-declare function knownPayload<T extends string>(input: Record<string, unknown>, allowed: readonly T[], operation: string): JsonObject;
-declare function topicPayload<T extends string>(input: TopicProjectAliasInput & Record<string, unknown>, allowed: readonly T[], operation: string): JsonObject;
-declare function listResultFromEnvelope<T, LegacyKey extends string>(data: unknown, legacyKey: LegacyKey): ListResult<T, LegacyKey>;
-
-export { type TopicProjectAliasInput, assertKnownKeys, cleanOptionalString, cleanRequiredString, knownPayload, listResultFromEnvelope, readTopicId, requireTopicId, topicPayload };
+export declare function cleanOptionalString(value: string | undefined): string | undefined;
+export declare function cleanRequiredString(value: string | undefined, label: string): string;
+export declare function readTopicId(input: TopicProjectAliasInput): string | undefined;
+export declare function requireTopicId(input: TopicProjectAliasInput): string;
+export declare function assertKnownKeys<T extends string>(input: Record<string, unknown>, allowed: readonly T[], operation: string): void;
+export declare function knownPayload<T extends string>(input: Record<string, unknown>, allowed: readonly T[], operation: string): JsonObject;
+export declare function topicPayload<T extends string>(input: TopicProjectAliasInput & Record<string, unknown>, allowed: readonly T[], operation: string): JsonObject;
+export declare function listResultFromEnvelope<T, LegacyKey extends string>(data: unknown, legacyKey: LegacyKey): ListResult<T, LegacyKey>;
+//# sourceMappingURL=boundaryClientSurface.d.ts.map

package/dist/boundaryClientSurface.js

@@ -1,73 +1,54 @@
-// src/sdkSurface.ts
-function createListResult(items, legacyKey) {
-  const result = {
-    items,
-    total: items.length
-  };
-  if (legacyKey) {
-    return {
-      ...result,
-      [legacyKey]: items
-    };
-  }
-  return result;
-}
-
-// src/boundaryClientSurface.ts
-function cleanOptionalString(value) {
-  const normalized = value?.trim();
-  return normalized ? normalized : void 0;
+import { createListResult } from "./sdkSurface.js";
+export function cleanOptionalString(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
 }
 function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function cleanRequiredString(value, label) {
-  const normalized = cleanOptionalString(value);
-  if (!normalized) {
-    throw new Error(`${label} is required`);
-  }
-  return normalized;
-}
-function readTopicId(input) {
-  return cleanOptionalString(input.topicId) ?? cleanOptionalString(input.projectId);
-}
-function requireTopicId(input) {
-  const topicId = readTopicId(input);
-  if (!topicId) {
-    throw new Error("topicId is required");
-  }
-  return topicId;
-}
-function assertKnownKeys(input, allowed, operation) {
-  const allowedSet = new Set(allowed);
-  const unknownKeys = Object.keys(input).filter((key) => !allowedSet.has(key));
-  if (unknownKeys.length > 0) {
-    throw new Error(
-      `${operation} received unsupported field(s): ${unknownKeys.join(", ")}`
-    );
-  }
-}
-function knownPayload(input, allowed, operation) {
-  assertKnownKeys(input, allowed, operation);
-  return { ...input };
-}
-function topicPayload(input, allowed, operation) {
-  assertKnownKeys(input, allowed, operation);
-  return {
-    ...input,
-    topicId: requireTopicId(input),
-    projectId: void 0
-  };
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function cleanRequiredString(value, label) {
+    const normalized = cleanOptionalString(value);
+    if (!normalized) {
+        throw new Error(`${label} is required`);
+    }
+    return normalized;
+}
+export function readTopicId(input) {
+    return cleanOptionalString(input.topicId) ?? cleanOptionalString(input.projectId);
+}
+export function requireTopicId(input) {
+    const topicId = readTopicId(input);
+    if (!topicId) {
+        throw new Error("topicId is required");
+    }
+    return topicId;
+}
+export function assertKnownKeys(input, allowed, operation) {
+    const allowedSet = new Set(allowed);
+    const unknownKeys = Object.keys(input).filter((key) => !allowedSet.has(key));
+    if (unknownKeys.length > 0) {
+        throw new Error(`${operation} received unsupported field(s): ${unknownKeys.join(", ")}`);
+    }
+}
+export function knownPayload(input, allowed, operation) {
+    assertKnownKeys(input, allowed, operation);
+    return { ...input };
+}
+export function topicPayload(input, allowed, operation) {
+    assertKnownKeys(input, allowed, operation);
+    return {
+        ...input,
+        topicId: requireTopicId(input),
+        projectId: undefined,
+    };
 }
-function listResultFromEnvelope(data, legacyKey) {
-  const record = isRecord(data) ? data : {};
-  const legacyItems = record[legacyKey];
-  return createListResult(
-    Array.isArray(legacyItems) ? legacyItems : Array.isArray(data) ? data : [],
-    legacyKey
-  );
+export function listResultFromEnvelope(data, legacyKey) {
+    const record = isRecord(data) ? data : {};
+    const legacyItems = record[legacyKey];
+    return createListResult(Array.isArray(legacyItems)
+        ? legacyItems
+        : Array.isArray(data)
+            ? data
+            : [], legacyKey);
 }
-
-export { assertKnownKeys, cleanOptionalString, cleanRequiredString, knownPayload, listResultFromEnvelope, readTopicId, requireTopicId, topicPayload };
-//# sourceMappingURL=boundaryClientSurface.js.map
 //# sourceMappingURL=boundaryClientSurface.js.map

package/dist/client.d.ts

@@ -1,59 +1,12 @@
-import { AddWorktreeInput, MergeInput, CreateTaskInput, CompleteTaskInput, UpdateTaskInput } from './workflowClient.js';
-import { JsonObject } from './types.js';
-import { LucernClientConfig, CustomToolInput, BeliefsCompatCreateInput, BeliefsCompatUpdateConfidenceInput, BeliefsCompatForkInput } from './clientConfig.js';
-import { FunctionSurfaceInput } from './functionSurface.js';
-import './coreClient.js';
-import '@lucern/transport-core';
-import './authContext.js';
-import './contracts/auth-session.contract.js';
-import './contracts/workflow-runtime.contract.js';
-import './contracts/lens-workflow.contract.js';
-import './contracts/lens-filter.contract.js';
-import './clientHelpers.js';
-import './adminClient.js';
-import './controlObjectOwnership.js';
-import './answersClient.js';
-import './audiencesClient.js';
-import './auditClient.js';
-import './beliefsClient.js';
-import './opinion.js';
-import './contextClient.js';
-import './contextTypes.js';
-import './control-plane.js';
-import './decisionsClient.js';
-import './embeddingsClient.js';
-import './boundaryClientSurface.js';
-import './eventingClient.js';
-import './evidenceClient.js';
-import './graphAnalysisClient.js';
-import '@lucern/contracts';
-import './graphClient.js';
-import './graphRecommendationsClient.js';
-import './graphStateClassifierClient.js';
-import './harnessClient.js';
-import './identityClient.js';
-import './jobsClient.js';
-import './learningClient.js';
-import './modelRuntimeClient.js';
-import './ontologyClient.js';
-import './ontologyLinksClient.js';
-import './orgGraphSearchClient.js';
-import './packsClient.js';
-import './policyClient.js';
-import './reportsClient.js';
-import './schemaClient.js';
-import './sourcesClient.js';
-import './telemetryClient.js';
-import './toolRegistryClient.js';
-import './topicsClient.js';
-
+import type { LucernClientConfig } from "./clientConfig";
+export type { LucernClientConfig } from "./clientConfig";
 /**
  * Create the high-level Lucern SDK client with all domain namespaces.
  *
  * @param config - Client configuration with API key, base URL, and optional settings.
  * @returns The Lucern client with namespaced methods for beliefs, topics, evidence, decisions, and more.
  */
-declare function createLucernClient(config?: LucernClientConfig): {
+export declare function createLucernClient(config?: LucernClientConfig): {
     coordination: {
         registerSession: any;
         heartbeatSession: any;
@@ -66,10 +19,10 @@ declare function createLucernClient(config?: LucernClientConfig): {
         claimFiles: any;
     };
     policy: {
-        checkPermission(input: FunctionSurfaceInput): any;
+        checkPermission(input: import("./functionSurface").FunctionSurfaceInput): any;
         listAccessibleTopics(input?: Parameters<(...args: any[]) => any>[0]): any;
-        filterByPermission(input: FunctionSurfaceInput): any;
-        manageWritePolicy(input: FunctionSurfaceInput, idempotencyKey?: string): any;
+        filterByPermission(input: import("./functionSurface").FunctionSurfaceInput): any;
+        manageWritePolicy(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
         raw: Record<string, (...args: any[]) => any> & {
             create: (...args: any[]) => any;
             link: (...args: any[]) => any;
@@ -88,17 +41,17 @@ declare function createLucernClient(config?: LucernClientConfig): {
         getFailureLog: any;
     };
     contracts: {
-        create(input: FunctionSurfaceInput): any;
-        createEpistemicContract(input: FunctionSurfaceInput): any;
+        create(input: import("./functionSurface").FunctionSurfaceInput): any;
+        createEpistemicContract(input: import("./functionSurface").FunctionSurfaceInput): any;
         list(input?: {
             beliefNodeId?: string;
             contractId?: string;
             status?: string;
         }): any;
-        evaluate(input: FunctionSurfaceInput): any;
-        evaluateContract(input: FunctionSurfaceInput): any;
-        getStatus(input: FunctionSurfaceInput): any;
-        getContractStatus(input: FunctionSurfaceInput): any;
+        evaluate(input: import("./functionSurface").FunctionSurfaceInput): any;
+        evaluateContract(input: import("./functionSurface").FunctionSurfaceInput): any;
+        getStatus(input: import("./functionSurface").FunctionSurfaceInput): any;
+        getContractStatus(input: import("./functionSurface").FunctionSurfaceInput): any;
     };
     bootstrap: {
         generateSessionHandoff: any;
@@ -136,7 +89,7 @@ declare function createLucernClient(config?: LucernClientConfig): {
         unregister: any;
         list: any;
         clear: any;
-        invoke(name: string, input?: CustomToolInput): any;
+        invoke(name: string, input?: import("./clientConfig").CustomToolInput): any;
         namespace: any;
     };
     packs: {
@@ -259,8 +212,8 @@ declare function createLucernClient(config?: LucernClientConfig): {
         list: any;
         get: any;
         recordOutcome: any;
-        lessons(decisionId: string, input: JsonObject, idempotencyKey?: string): Promise<any>;
-        archive(decisionId: string, input?: JsonObject, idempotencyKey?: string): Promise<any>;
+        lessons(decisionId: string, input: import("./types").JsonObject, idempotencyKey?: string): Promise<any>;
+        archive(decisionId: string, input?: import("./types").JsonObject, idempotencyKey?: string): Promise<any>;
         readiness(topicId: string): any;
         calibration(topicId: string): any;
         pendingOutcomeReview(topicId: string): any;
@@ -271,8 +224,8 @@ declare function createLucernClient(config?: LucernClientConfig): {
         listLenses: (...args: any[]) => any;
         applyLensToTopic: (...args: any[]) => any;
         removeLensFromTopic: (...args: any[]) => any;
-        create(input: AddWorktreeInput): any;
-        add(input: AddWorktreeInput): any;
+        create(input: import("./workflowClient").AddWorktreeInput): any;
+        add(input: import("./workflowClient").AddWorktreeInput): any;
         list(query: Parameters<(...args: any[]) => any>[0]): any;
         listByTopic(query: Parameters<(...args: any[]) => any>[0]): any;
         findByPairedSprint(input: {
@@ -282,11 +235,11 @@ declare function createLucernClient(config?: LucernClientConfig): {
             limit?: number;
         }): Promise<any>;
         activate(worktreeId: string): any;
-        updateMetadata(input: FunctionSurfaceInput): any;
-        update(input: FunctionSurfaceInput): any;
+        updateMetadata(input: import("./functionSurface").FunctionSurfaceInput): any;
+        update(input: import("./functionSurface").FunctionSurfaceInput): any;
         updateTargets(input: Parameters<(...args: any[]) => any>[0]): any;
         listAll: (...args: any[]) => any;
-        merge(worktreeId: string, input: MergeInput): any;
+        merge(worktreeId: string, input: import("./workflowClient").MergeInput): any;
         push: (...args: any[]) => any;
         openPullRequest: (...args: any[]) => any;
         pipelineSnapshot(topicId: string): any;
@@ -300,27 +253,27 @@ declare function createLucernClient(config?: LucernClientConfig): {
         listTopics(query?: Parameters<(...args: any[]) => any>[0]): any;
         compile: any;
         recordScopeLearning: any;
-        discover(input: FunctionSurfaceInput): any;
+        discover(input: import("./functionSurface").FunctionSurfaceInput): any;
         analyzeTopicDensity: any;
         applyAutoBranching: any;
         seedBeliefLattice: any;
         getLatticeCoverage: any;
-        matchEntityType(input: FunctionSurfaceInput): any;
-        discoverEntityConnections(input: FunctionSurfaceInput): any;
-        triggerBeliefReview(input: FunctionSurfaceInput): any;
+        matchEntityType(input: import("./functionSurface").FunctionSurfaceInput): any;
+        discoverEntityConnections(input: import("./functionSurface").FunctionSurfaceInput): any;
+        triggerBeliefReview(input: import("./functionSurface").FunctionSurfaceInput): any;
     };
     tasks: {
-        create(input: CreateTaskInput): any;
-        complete(taskId: string, input: CompleteTaskInput): any;
-        update(taskId: string, input: UpdateTaskInput): any;
-        list(input: FunctionSurfaceInput): any;
-        listByTopic(input: FunctionSurfaceInput & {
+        create(input: import("./workflowClient").CreateTaskInput): any;
+        complete(taskId: string, input: import("./workflowClient").CompleteTaskInput): any;
+        update(taskId: string, input: import("./workflowClient").UpdateTaskInput): any;
+        list(input: import("./functionSurface").FunctionSurfaceInput): any;
+        listByTopic(input: import("./functionSurface").FunctionSurfaceInput & {
             topicId?: string;
         }): any;
-        listByWorktree(input: FunctionSurfaceInput & {
+        listByWorktree(input: import("./functionSurface").FunctionSurfaceInput & {
             worktreeId: string;
         }): any;
-        linkChat(taskId: string, input: JsonObject, idempotencyKey?: string): Promise<any>;
+        linkChat(taskId: string, input: import("./types").JsonObject, idempotencyKey?: string): Promise<any>;
     };
     topics: {
         list(input?: Parameters<(...args: any[]) => any>[0]): any;
@@ -335,14 +288,14 @@ declare function createLucernClient(config?: LucernClientConfig): {
         coverage(topicId: string, query?: Parameters<(...args: any[]) => any>[1]): any;
         remove: (...args: any[]) => any;
         bulkCreate: (...args: any[]) => any;
-        materializeGraph(input?: FunctionSurfaceInput, idempotencyKey?: string): any;
-        materializeTopicGraph(input?: FunctionSurfaceInput, idempotencyKey?: string): any;
-        graphSpine(input?: FunctionSurfaceInput): any;
-        getTopicGraphSpine(input?: FunctionSurfaceInput): any;
+        materializeGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
+        materializeTopicGraph(input?: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
+        graphSpine(input?: import("./functionSurface").FunctionSurfaceInput): any;
+        getTopicGraphSpine(input?: import("./functionSurface").FunctionSurfaceInput): any;
     };
     answers: {
-        create(input: FunctionSurfaceInput): any;
-        get(input: FunctionSurfaceInput): any;
+        create(input: import("./functionSurface").FunctionSurfaceInput): any;
+        get(input: import("./functionSurface").FunctionSurfaceInput): any;
     };
     contradictions: {
         flag(args: {
@@ -371,16 +324,16 @@ declare function createLucernClient(config?: LucernClientConfig): {
         get(ontologyId: string): any;
         bind(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: Parameters<(...args: any[]) => any>[1]): any;
         match(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: Parameters<(...args: any[]) => any>[1]): any;
-        create(input: FunctionSurfaceInput): any;
-        update(input: FunctionSurfaceInput): any;
-        archive(input: FunctionSurfaceInput): any;
-        createVersion(input: FunctionSurfaceInput): any;
-        publishVersion(input: FunctionSurfaceInput): any;
-        publishOntologyVersion(input: FunctionSurfaceInput): any;
-        deprecateVersion(input: FunctionSurfaceInput): any;
-        deprecateOntologyVersion(input: FunctionSurfaceInput): any;
-        resolveEffective(input: FunctionSurfaceInput): any;
-        resolveEffectiveOntology(input: FunctionSurfaceInput): any;
+        create(input: import("./functionSurface").FunctionSurfaceInput): any;
+        update(input: import("./functionSurface").FunctionSurfaceInput): any;
+        archive(input: import("./functionSurface").FunctionSurfaceInput): any;
+        createVersion(input: import("./functionSurface").FunctionSurfaceInput): any;
+        publishVersion(input: import("./functionSurface").FunctionSurfaceInput): any;
+        publishOntologyVersion(input: import("./functionSurface").FunctionSurfaceInput): any;
+        deprecateVersion(input: import("./functionSurface").FunctionSurfaceInput): any;
+        deprecateOntologyVersion(input: import("./functionSurface").FunctionSurfaceInput): any;
+        resolveEffective(input: import("./functionSurface").FunctionSurfaceInput): any;
+        resolveEffectiveOntology(input: import("./functionSurface").FunctionSurfaceInput): any;
         raw: any;
     };
     graph: {
@@ -478,14 +431,14 @@ declare function createLucernClient(config?: LucernClientConfig): {
         updateDeliveryStatus: any;
     };
     beliefs: {
-        create(input: BeliefsCompatCreateInput): any;
+        create(input: import("./clientConfig").BeliefsCompatCreateInput): any;
         get(nodeId: string): any;
         refine(nodeId: string, textOrInput: string | {
             text: string;
             rationale?: string;
         }, rationale?: string): any;
-        updateConfidence(nodeId: string, input: BeliefsCompatUpdateConfidenceInput): any;
-        modulateConfidence(nodeId: string, input: BeliefsCompatUpdateConfidenceInput): any;
+        updateConfidence(nodeId: string, input: import("./clientConfig").BeliefsCompatUpdateConfidenceInput): any;
+        modulateConfidence(nodeId: string, input: import("./clientConfig").BeliefsCompatUpdateConfidenceInput): any;
         updateStatus(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
         updateRationale(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
         linkBeliefs(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
@@ -493,7 +446,7 @@ declare function createLucernClient(config?: LucernClientConfig): {
         updateCriticality(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
         batchUpdateCriticality(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
         reassignTopic(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        fork(nodeId: string, input: BeliefsCompatForkInput): any;
+        fork(nodeId: string, input: import("./clientConfig").BeliefsCompatForkInput): any;
         archive(nodeId: string, input?: string | {
             reason?: string;
             rationale?: string;
@@ -524,7 +477,7 @@ declare function createLucernClient(config?: LucernClientConfig): {
         health(id: string): any;
     };
     edges: {
-        create(args: FunctionSurfaceInput & {
+        create(args: import("./functionSurface").FunctionSurfaceInput & {
             from?: unknown;
             to?: unknown;
             sourceId?: string;
@@ -536,15 +489,15 @@ declare function createLucernClient(config?: LucernClientConfig): {
             context?: string;
             reasoning?: string;
         }, idempotencyKey?: string): any;
-        createEdge(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        update(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        updateEdge(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        remove(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        removeEdge(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        removeBetween(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        removeEdgesBetween(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        batchCreate(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        batchCreateEdges(input: FunctionSurfaceInput, idempotencyKey?: string): any;
+        createEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
+        update(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
+        updateEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
+        remove(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
+        removeEdge(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
+        removeBetween(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
+        removeEdgesBetween(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
+        batchCreate(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
+        batchCreateEdges(input: import("./functionSurface").FunctionSurfaceInput, idempotencyKey?: string): any;
         delete(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
         list(args: {
             sourceId: string;
@@ -568,11 +521,24 @@ declare function createLucernClient(config?: LucernClientConfig): {
             sourceUrl?: string;
             targetId?: string;
             weight?: number;
-            metadata?: JsonObject;
+            evidenceRelation?: "supports" | "contradicts";
+            confidence?: number;
+            beliefRelations?: Array<{
+                beliefId?: string;
+                beliefNodeId?: string;
+                targetId?: string;
+                relation?: "supports" | "contradicts" | "supporting" | "contradicting";
+                evidenceRelation?: "supports" | "contradicts";
+                confidence?: number;
+                weight?: number;
+                rationale?: string;
+            }>;
+            metadata?: import("./types").JsonObject;
             title?: string;
             content?: string;
             contentType?: string;
             kind?: string;
+            rationale?: string;
             supports?: {
                 nodeId: string;
                 weight: number;
@@ -603,12 +569,16 @@ declare function createLucernClient(config?: LucernClientConfig): {
             questionId?: string;
             targetType?: "belief" | "question" | string;
             weight?: number;
+            evidenceRelation?: "supports" | "contradicts";
+            confidence?: number;
             rationale?: string;
         }): any;
         linkToBelief(args: {
             evidenceId: string;
             beliefId: string;
-            weight: number;
+            weight?: number;
+            evidenceRelation?: "supports" | "contradicts";
+            confidence?: number;
             rationale?: string;
         }): any;
         classifyEvidence(beliefId: string, evidenceId: string, config?: Parameters<any>[2], idempotencyKey?: string): any;
@@ -629,7 +599,7 @@ declare function createLucernClient(config?: LucernClientConfig): {
             topicId?: string;
             priority?: string;
             linkedBeliefId?: string;
-            metadata?: JsonObject;
+            metadata?: import("./types").JsonObject;
         }): any;
         get(questionId: string): any;
         refine(questionId: string, text: string, refinementReason?: string): any;
@@ -685,5 +655,4 @@ declare function createLucernClient(config?: LucernClientConfig): {
         cursor?: string;
     }) => Promise<any>;
 };
-
-export { LucernClientConfig, createLucernClient };
+//# sourceMappingURL=client.d.ts.map