@lucern/sdk 1.0.29 → 1.0.30

package/dist/events.d.ts

@@ -7,141 +7,141 @@ export type DomainEventType = (typeof DOMAIN_EVENT_TYPES)[number];
 export type DomainResourceType = "belief" | "evidence" | "question" | "edge" | "contradiction" | "worktree" | "topic" | "task" | "ontology" | "context" | "identity" | "webhook";
 export type DomainActorType = "human" | "agent" | "service";
 export type DomainEventData = Record<string, unknown>;
-export type DomainEvent = {
-    eventId: string;
-    type: DomainEventType | string;
-    version: typeof DOMAIN_EVENT_VERSION;
-    timestamp: number;
-    tenantId?: string;
-    workspaceId?: string;
-    topicId: string;
-    resourceId: string;
-    resourceType: DomainResourceType | string;
+export interface DomainEvent {
     actorId: string;
     actorType: DomainActorType;
-    data: DomainEventData;
     correlationId?: string;
+    data: DomainEventData;
+    eventId: string;
     expiresAt: number;
-};
-export type CreateDomainEventInput = {
-    eventId?: string;
-    timestamp?: number;
+    resourceId: string;
+    resourceType: DomainResourceType | string;
     tenantId?: string;
-    workspaceId?: string;
+    timestamp: number;
     topicId: string;
     type: DomainEventType | string;
-    resourceId: string;
-    resourceType: DomainResourceType | string;
+    version: typeof DOMAIN_EVENT_VERSION;
+    workspaceId?: string;
+}
+export interface CreateDomainEventInput {
     actorId: string;
     actorType: DomainActorType;
-    data?: DomainEventData;
     correlationId?: string;
+    data?: DomainEventData;
+    eventId?: string;
+    resourceId: string;
+    resourceType: DomainResourceType | string;
     retentionDays?: number;
-};
-export type EventCursor = {
-    timestamp: number;
+    tenantId?: string;
+    timestamp?: number;
+    topicId: string;
+    type: DomainEventType | string;
+    workspaceId?: string;
+}
+export interface EventCursor {
     eventId: string;
-};
-export type EventListQuery = {
-    topicId?: string;
+    timestamp: number;
+}
+export interface EventListQuery {
     after?: string;
-    types?: string[];
-    startTime?: number;
     endTime?: number;
     limit?: number;
-};
-export type EventListResult = {
+    startTime?: number;
+    topicId?: string;
+    types?: string[];
+}
+export interface EventListResult {
     events: DomainEvent[];
     nextCursor: string | null;
-};
+}
 export type WebhookSecretMode = "configured";
-export type WebhookRecord = {
-    id: string;
-    webhookId: string;
-    tenantId?: string;
-    workspaceId?: string;
-    topicId?: string;
-    url: string;
-    events: string[];
+export interface WebhookRecord {
     active: boolean;
-    secretConfigured: boolean;
     createdAt: number;
-    updatedAt: number;
     createdBy: string;
-    updatedBy: string;
+    events: string[];
+    id: string;
     lastDeliveryAt?: number;
     lastSuccessfulDeliveryAt?: number;
-};
-export type WebhookCreateInput = {
+    secretConfigured: boolean;
+    tenantId?: string;
+    topicId?: string;
+    updatedAt: number;
+    updatedBy: string;
     url: string;
+    webhookId: string;
+    workspaceId?: string;
+}
+export interface WebhookCreateInput {
+    active?: boolean;
     events: string[];
     secret: string;
     topicId?: string;
+    url: string;
+}
+export interface WebhookUpdateInput {
     active?: boolean;
-};
-export type WebhookUpdateInput = {
-    url?: string;
     events?: string[];
     secret?: string;
     topicId?: string | null;
-    active?: boolean;
-};
+    url?: string;
+}
 export type WebhookDeliveryStatus = "pending" | "delivering" | "succeeded" | "failed" | "dead_letter";
-export type WebhookDeliveryRecord = {
-    id: string;
+export interface WebhookDeliveryRecord {
+    attemptCount: number;
+    createdAt: number;
+    deliveredAt?: number;
     deliveryId: string;
-    webhookId: string;
     eventId: string;
     eventType: string;
-    topicId: string;
-    status: WebhookDeliveryStatus;
-    attemptCount: number;
-    maxAttempts: number;
-    nextAttemptAt?: number;
+    id: string;
     lastAttemptAt?: number;
-    lastStatusCode?: number;
     lastError?: string;
-    deliveredAt?: number;
-    createdAt: number;
+    lastStatusCode?: number;
+    maxAttempts: number;
+    nextAttemptAt?: number;
+    status: WebhookDeliveryStatus;
+    topicId: string;
     updatedAt: number;
-};
-export type WebhookDeliveryAttemptRecord = {
-    id: string;
+    webhookId: string;
+}
+export interface WebhookDeliveryAttemptRecord {
     attemptId: string;
+    attemptNumber: number;
+    createdAt: number;
     deliveryId: string;
-    webhookId: string;
+    durationMs?: number;
+    error?: string;
     eventId: string;
     eventType: string;
-    attemptNumber: number;
+    id: string;
+    responseBody?: string;
     status: "succeeded" | "failed";
     statusCode?: number;
-    error?: string;
-    responseBody?: string;
-    durationMs?: number;
-    createdAt: number;
-};
-export type WebhookDeliveriesResult = {
+    webhookId: string;
+}
+export interface WebhookDeliveriesResult {
     deliveries: Array<WebhookDeliveryRecord & {
         attempts?: WebhookDeliveryAttemptRecord[];
     }>;
-};
-export type WebhookHealthResult = {
-    webhookId: string;
-    totalAttempts: number;
-    successfulAttempts: number;
-    failedAttempts: number;
-    successRate: number;
-    pendingDeliveries: number;
+}
+export interface WebhookHealthResult {
     deadLetterDeliveries: number;
+    failedAttempts: number;
     lastDeliveryAt?: number;
     lastSuccessfulDeliveryAt?: number;
-};
-export type WebhookTestResult = {
+    pendingDeliveries: number;
+    successfulAttempts: number;
+    successRate: number;
+    totalAttempts: number;
     webhookId: string;
+}
+export interface WebhookTestResult {
+    attempts: number;
     deliveryId: string;
     status: WebhookDeliveryStatus;
-    attempts: number;
-};
+    webhookId: string;
+}
 export type ReplayEventsInput = EventListQuery & {
     webhookId?: string;
 };
@@ -165,7 +165,7 @@ export declare function inferActorType(args: {
     authMode?: string;
     principalType?: string;
 }): DomainActorType;
-export declare function emitDomainEvent(invokeMutation: (reference: any, args: CreateDomainEventInput) => Promise<unknown>, input: CreateDomainEventInput): Promise<unknown>;
+export declare function emitDomainEvent(invokeMutation: (reference: string, args: CreateDomainEventInput) => Promise<unknown>, input: CreateDomainEventInput): Promise<unknown>;
 export declare function assertValidWebhookUrl(url: string): string;
 export declare function normalizeWebhookPatterns(patterns: readonly string[]): string[];
 export declare function assertValidWebhookSecret(secret: string): string;

package/dist/events.js

@@ -1,7 +1,9 @@
 export const DOMAIN_EVENT_VERSION = "1.0";
 export const EVENT_RETENTION_DEFAULT_DAYS = 30;
 export const WEBHOOK_MAX_ATTEMPTS = 5;
-export const WEBHOOK_RETRY_DELAYS_MS = [1_000, 5_000, 30_000, 300_000];
+export const WEBHOOK_RETRY_DELAYS_MS = [1000, 5000, 30_000, 300_000];
+const EMPTY_EVENT_PATTERN = /^$/;
+const ANY_EVENT_PATTERN = /^.*$/;
 export const DOMAIN_EVENT_TYPES = [
     "belief.created",
     "belief.forked",
@@ -47,10 +49,10 @@ function escapeRegex(value) {
 export function eventPatternToRegExp(pattern) {
     const normalized = pattern.trim();
     if (!normalized) {
-        return /^$/;
+        return EMPTY_EVENT_PATTERN;
     }
     if (normalized === "*") {
-        return /^.*$/;
+        return ANY_EVENT_PATTERN;
     }
     const source = escapeRegex(normalized).replace(/\\\*/g, ".*");
     return new RegExp(`^${source}$`);
@@ -144,8 +146,7 @@ export function decodeEventCursor(cursor) {
             eventId: parsed.eventId.trim(),
         };
     }
-    catch (error) {
-        void error;
+    catch {
         return null;
     }
 }
@@ -169,16 +170,15 @@ export function inferActorType(args) {
     }
     return "human";
 }
-export async function emitDomainEvent(invokeMutation, input) {
-    return await invokeMutation("events:recordEvent", input);
+export function emitDomainEvent(invokeMutation, input) {
+    return invokeMutation("events:recordEvent", input);
 }
 const LOCALHOST_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
 function normalizeUrl(url) {
     try {
         return new URL(url.trim());
     }
-    catch (error) {
-        void error;
+    catch {
         throw new Error("Webhook URL must be a valid absolute URL.");
     }
 }
@@ -187,7 +187,8 @@ export function assertValidWebhookUrl(url) {
     const hostname = parsed.hostname.trim().toLowerCase();
     const nodeEnv = RUNTIME_ENV?.NODE_ENV;
     const allowLocalHttp = nodeEnv === "test" || LOCALHOST_HOSTS.has(hostname);
-    if (parsed.protocol !== "https:" && !(allowLocalHttp && parsed.protocol === "http:")) {
+    if (parsed.protocol !== "https:" &&
+        !(allowLocalHttp && parsed.protocol === "http:")) {
         throw new Error("Webhook URL must use HTTPS.");
     }
     return parsed.toString();
@@ -218,7 +219,7 @@ export async function computeWebhookSignature(payload, secret) {
 }
 export function nextDeliveryAttemptAt(currentAttemptCount, now = Date.now()) {
     if (currentAttemptCount >= WEBHOOK_MAX_ATTEMPTS) {
-        return undefined;
+        return;
     }
     const retryIndex = currentAttemptCount - 1;
     const delay = WEBHOOK_RETRY_DELAYS_MS[retryIndex];
@@ -234,7 +235,8 @@ export function sanitizeWebhookRecord(value) {
         tenantId: typeof value.tenantId === "string" && value.tenantId.trim().length > 0
             ? value.tenantId
             : undefined,
-        workspaceId: typeof value.workspaceId === "string" && value.workspaceId.trim().length > 0
+        workspaceId: typeof value.workspaceId === "string" &&
+            value.workspaceId.trim().length > 0
             ? value.workspaceId
             : undefined,
         topicId: typeof value.topicId === "string" && value.topicId.trim().length > 0
@@ -252,15 +254,17 @@ export function sanitizeWebhookRecord(value) {
         updatedAt: Number(value.updatedAt ?? value.createdAt ?? Date.now()),
         createdBy: String(value.createdBy ?? ""),
         updatedBy: String(value.updatedBy ?? value.createdBy ?? ""),
-        lastDeliveryAt: typeof value.lastDeliveryAt === "number" ? value.lastDeliveryAt : undefined,
+        lastDeliveryAt: typeof value.lastDeliveryAt === "number"
+            ? value.lastDeliveryAt
+            : undefined,
         lastSuccessfulDeliveryAt: typeof value.lastSuccessfulDeliveryAt === "number"
             ? value.lastSuccessfulDeliveryAt
             : undefined,
     };
 }
-export function truncateWebhookResponseBody(responseBody, maxLength = 2_000) {
+export function truncateWebhookResponseBody(responseBody, maxLength = 2000) {
     if (!responseBody) {
-        return undefined;
+        return;
     }
     if (responseBody.length <= maxLength) {
         return responseBody;

package/dist/eventsCore.d.ts

@@ -4,16 +4,16 @@ export type EventsClientCoreConfig = GatewayClientConfig;
 export type EventsListResponse = PlatformGatewaySuccess<EventListResult>;
 export type EventsReplayResponse = PlatformGatewaySuccess<ReplayEventsResult>;
 export type WebhooksClientCoreConfig = GatewayClientConfig;
-export type WebhookListQuery = {
+export interface WebhookListQuery {
     topicId?: string;
-};
-export type WebhookDeliveriesQuery = {
+}
+export interface WebhookDeliveriesQuery {
     limit?: number;
-};
-export type WebhookDeleteResult = {
-    webhookId: string;
+}
+export interface WebhookDeleteResult {
     deleted: boolean;
-};
+    webhookId: string;
+}
 export type WebhooksCreateResponse = PlatformGatewaySuccess<WebhookRecord>;
 export type WebhooksListResponse = PlatformGatewaySuccess<{
     webhooks: WebhookRecord[];

package/dist/eventsCore.js

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/style/useFilenamingConvention: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the camelCase filename is intentional.
 import { createGatewayRequestClient, randomIdempotencyKey, toQueryString, } from "./coreClient.js";
 function serializeTypes(types) {
     return Array.isArray(types) && types.length > 0 ? types.join(",") : undefined;
@@ -5,7 +6,7 @@ function serializeTypes(types) {
 export function createEventsClientCore(config = {}) {
     const gateway = createGatewayRequestClient(config);
     return {
-        async list(query = {}) {
+        list(query = {}) {
             return gateway.request({
                 path: `/v1/events${toQueryString({
                     topicId: query.topicId,
@@ -17,7 +18,7 @@ export function createEventsClientCore(config = {}) {
                 })}`,
             });
         },
-        async replay(input, idempotencyKey = randomIdempotencyKey()) {
+        replay(input, idempotencyKey = randomIdempotencyKey()) {
             return gateway.request({
                 path: "/v1/events/replay",
                 method: "POST",
@@ -30,7 +31,7 @@ export function createEventsClientCore(config = {}) {
 export function createWebhooksClientCore(config = {}) {
     const gateway = createGatewayRequestClient(config);
     return {
-        async create(input, idempotencyKey = randomIdempotencyKey()) {
+        create(input, idempotencyKey = randomIdempotencyKey()) {
             return gateway.request({
                 path: "/v1/webhooks",
                 method: "POST",
@@ -38,19 +39,19 @@ export function createWebhooksClientCore(config = {}) {
                 idempotencyKey,
             });
         },
-        async list(query = {}) {
+        list(query = {}) {
             return gateway.request({
                 path: `/v1/webhooks${toQueryString({
                     topicId: query.topicId,
                 })}`,
             });
         },
-        async get(id) {
+        get(id) {
             return gateway.request({
                 path: `/v1/webhooks/${encodeURIComponent(id)}`,
             });
         },
-        async update(id, input, idempotencyKey = randomIdempotencyKey()) {
+        update(id, input, idempotencyKey = randomIdempotencyKey()) {
             return gateway.request({
                 path: `/v1/webhooks/${encodeURIComponent(id)}`,
                 method: "PATCH",
@@ -58,14 +59,14 @@ export function createWebhooksClientCore(config = {}) {
                 idempotencyKey,
             });
         },
-        async delete(id, idempotencyKey = randomIdempotencyKey()) {
+        delete(id, idempotencyKey = randomIdempotencyKey()) {
             return gateway.request({
                 path: `/v1/webhooks/${encodeURIComponent(id)}`,
                 method: "DELETE",
                 idempotencyKey,
             });
         },
-        async test(id, input = {}, idempotencyKey = randomIdempotencyKey()) {
+        test(id, input = {}, idempotencyKey = randomIdempotencyKey()) {
             return gateway.request({
                 path: `/v1/webhooks/${encodeURIComponent(id)}/test`,
                 method: "POST",
@@ -73,14 +74,14 @@ export function createWebhooksClientCore(config = {}) {
                 idempotencyKey,
             });
         },
-        async deliveries(id, query = {}) {
+        deliveries(id, query = {}) {
             return gateway.request({
                 path: `/v1/webhooks/${encodeURIComponent(id)}/deliveries${toQueryString({
                     limit: query.limit,
                 })}`,
             });
         },
-        async health(id) {
+        health(id) {
             return gateway.request({
                 path: `/v1/webhooks/${encodeURIComponent(id)}/health`,
             });

package/dist/evidence/index.d.ts

@@ -4,14 +4,14 @@ export * as toolSchemas from "@lucern/contracts/tool-contracts";
 export type EvidenceClientConfig = LucernClientConfig;
 export type EvidenceClient = ReturnType<typeof createEvidenceClient>;
 export declare function createEvidenceClient(config?: EvidenceClientConfig): {
-    createEvidence: (args: import("../clientEvidenceCompat").EvidenceCompatInput) => any;
-    getEvidence: (evidenceId: string) => any;
+    createEvidence: (args: import("../client-evidence-compat").EvidenceCompatInput) => Promise<import("../client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+    getEvidence: (evidenceId: string) => Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayRecord>>;
     listEvidence: (args: {
         topicId?: string;
         targetId?: string;
         limit?: number;
         cursor?: string;
-    }) => any;
+    }) => Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayList>>;
     searchEvidence: (args: {
         q?: string;
         query?: string;
@@ -20,7 +20,7 @@ export declare function createEvidenceClient(config?: EvidenceClientConfig): {
         methodology?: string;
         limit?: number;
         cursor?: string;
-    }) => any;
+    }) => Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayList>>;
     linkEvidence: (args: {
         evidenceId: string;
         targetId?: string;
@@ -31,19 +31,19 @@ export declare function createEvidenceClient(config?: EvidenceClientConfig): {
         evidenceRelation?: "supports" | "contradicts";
         confidence?: number;
         rationale?: string;
-    }) => any;
-    classifyEvidence: (beliefId: string, evidenceId: string, config?: Parameters<any>[2], idempotencyKey?: string) => any;
-    classifyEvidenceBatch: (beliefId: string, evidence: Parameters<any>[1], config?: Parameters<any>[2], idempotencyKey?: string) => any;
+    }) => Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").EvidenceLinkResult>>;
+    classifyEvidence: (beliefId: string, evidenceId: string, config?: Parameters<(beliefId: string, evidenceId: string, classificationConfig?: import("..").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").ClassifyEvidenceResult>>>[2], idempotencyKey?: string) => Promise<import("../client-config").GatewayDataEnvelope<import("..").ClassifyEvidenceResult>>;
+    classifyEvidenceBatch: (beliefId: string, evidence: Parameters<(beliefId: string, evidence: import("..").ClassifyEvidenceBatchItem[], classificationConfig?: import("..").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").ClassifyEvidenceBatchResult>>>[1], config?: Parameters<(beliefId: string, evidence: import("..").ClassifyEvidenceBatchItem[], classificationConfig?: import("..").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").ClassifyEvidenceBatchResult>>>[2], idempotencyKey?: string) => Promise<import("../client-config").GatewayDataEnvelope<import("..").ClassifyEvidenceBatchResult>>;
     raw: {
-        create(args: import("../clientEvidenceCompat").EvidenceCompatInput): any;
-        add: any;
-        get(evidenceId: string): any;
+        create(args: import("../client-evidence-compat").EvidenceCompatInput): Promise<import("../client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        add: (args_0: import("../client-evidence-compat").EvidenceCompatInput) => Promise<import("..").PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        get(evidenceId: string): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayRecord>>;
         list(args: {
             topicId?: string;
             targetId?: string;
             limit?: number;
             cursor?: string;
-        }): any;
+        }): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayList>>;
         search(args: {
             q?: string;
             query?: string;
@@ -52,7 +52,7 @@ export declare function createEvidenceClient(config?: EvidenceClientConfig): {
             methodology?: string;
             limit?: number;
             cursor?: string;
-        }): any;
+        }): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayList>>;
         link(args: {
             evidenceId: string;
             targetId?: string;
@@ -63,7 +63,7 @@ export declare function createEvidenceClient(config?: EvidenceClientConfig): {
             evidenceRelation?: "supports" | "contradicts";
             confidence?: number;
             rationale?: string;
-        }): any;
+        }): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").EvidenceLinkResult>>;
         linkToBelief(args: {
             evidenceId: string;
             beliefId: string;
@@ -71,14 +71,16 @@ export declare function createEvidenceClient(config?: EvidenceClientConfig): {
             evidenceRelation?: "supports" | "contradicts";
             confidence?: number;
             rationale?: string;
-        }): any;
-        classifyEvidence(beliefId: string, evidenceId: string, config?: Parameters<any>[2], idempotencyKey?: string): any;
-        classifyEvidenceBatch(beliefId: string, evidence: Parameters<any>[1], config?: Parameters<any>[2], idempotencyKey?: string): any;
-        updateStatus(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        update(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        flagIncorrect(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        remove(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
-        updateVerificationStatus(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
+        }): Promise<{
+            beliefId: string;
+        }>;
+        classifyEvidence(beliefId: string, evidenceId: string, config?: Parameters<(beliefId: string, evidenceId: string, classificationConfig?: import("..").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").ClassifyEvidenceResult>>>[2], idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<import("..").ClassifyEvidenceResult>>;
+        classifyEvidenceBatch(beliefId: string, evidence: Parameters<(beliefId: string, evidence: import("..").ClassifyEvidenceBatchItem[], classificationConfig?: import("..").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").ClassifyEvidenceBatchResult>>>[1], config?: Parameters<(beliefId: string, evidence: import("..").ClassifyEvidenceBatchItem[], classificationConfig?: import("..").EvidenceClassificationRequestConfig, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("..").ClassifyEvidenceBatchResult>>>[2], idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<import("..").ClassifyEvidenceBatchResult>>;
+        updateStatus(input: Parameters<(input: import("../gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("../gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayRecord>>;
+        update(input: Parameters<(input: import("../gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("../gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayRecord>>;
+        flagIncorrect(input: Parameters<(input: import("../gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("../gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayRecord>>;
+        remove(input: Parameters<(input: import("../gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("../gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayRecord>>;
+        updateVerificationStatus(input: Parameters<(input: import("../gatewayFacades").GatewayRecord, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("../gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayRecord>>;
     };
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/evidence/index.js

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/performance/noBarrelFile: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the facade/barrel export is intentional.
 import { createLucernClient } from "../client.js";
 export * as evidenceContracts from "@lucern/contracts/evidence/v1";
 export * as toolSchemas from "@lucern/contracts/tool-contracts";

package/dist/evidenceClient.d.ts

@@ -1,15 +1,15 @@
 import { type GatewayClientConfig } from "./coreClient";
 type EvidenceClassificationRelation = "supports" | "contradicts" | "irrelevant";
-type ModelFallbackConfig = {
-    modelKey: string;
+interface ModelFallbackConfig {
+    maxTokens: number;
     modelId: string;
+    modelKey: string;
     temperature: number;
-    maxTokens: number;
-};
+}
 type ResolvedModelConfig = ModelFallbackConfig & {
     promptName: string;
 };
-type TracingAdapter = {
+interface TracingAdapter {
     startGeneration(input: {
         name: string;
         userId?: string;
@@ -21,7 +21,7 @@ type TracingAdapter = {
         end: (output: unknown) => Promise<void>;
         error: (err: unknown) => Promise<void>;
     }>;
-};
+}
 type PromptResolver = (name: string) => Promise<string | null>;
 type ModelResolver = (slotKey: string, fallback: ResolvedModelConfig) => Promise<ResolvedModelConfig>;
 type ClassificationRuntimeAdapter = (input: {
@@ -35,20 +35,20 @@ type ClassificationRuntimeAdapter = (input: {
     relation: EvidenceClassificationRelation;
     rationale: string;
 }>;
-export type SerializableClassifyEvidenceConfig = {
-    promptName?: string;
-    modelSlotKey?: string;
-    modelFallback?: ModelFallbackConfig;
+export interface SerializableClassifyEvidenceConfig {
     edgeWeightPolicy?: {
         supports: number;
         contradicts: number;
     };
+    modelFallback?: ModelFallbackConfig;
+    modelSlotKey?: string;
+    promptName?: string;
     statusTransition?: {
         onSupports: string;
         onContradicts: string;
     };
     writeLegacyTables?: boolean;
-};
+}
 export type ClassifyEvidenceConfig = SerializableClassifyEvidenceConfig & {
     trustDiscountPolicy?: (relation: Exclude<EvidenceClassificationRelation, "irrelevant">, rationale: string) => number;
     tracing?: TracingAdapter;
@@ -56,41 +56,41 @@ export type ClassifyEvidenceConfig = SerializableClassifyEvidenceConfig & {
     modelResolver?: ModelResolver;
     classifier?: ClassificationRuntimeAdapter;
 };
-export type ClassifyEvidenceResult = {
+export interface ClassifyEvidenceResult {
     beliefId: string;
-    evidenceId: string;
-    relation: EvidenceClassificationRelation;
-    rationale: string;
-    usedFallback: boolean;
     edgeWeight?: number;
-    promptName: string;
-    model: ResolvedModelConfig;
+    evidenceId: string;
     link?: {
         edgeGlobalId: string;
         linkId?: string;
         confidence: number;
         writeLegacyTables: boolean;
     };
+    model: ResolvedModelConfig;
+    promptName: string;
+    rationale: string;
+    relation: EvidenceClassificationRelation;
     statusUpdate?: {
         previousStatus?: string;
         newStatus: string;
         historyWritten: boolean;
     };
-};
-export type ClassifyEvidenceBatchItem = {
+    usedFallback: boolean;
+}
+export interface ClassifyEvidenceBatchItem {
     evidenceId?: string;
     insightId?: string;
     nodeId?: string;
     text?: string;
-};
-export type ClassifyEvidenceBatchResult = {
+}
+export interface ClassifyEvidenceBatchResult {
     items: ClassifyEvidenceResult[];
     summary: {
         supporting: number;
         contradicting: number;
         irrelevant: number;
     };
-};
+}
 export type { PlatformGatewaySuccess } from "./coreClient";
 /** Configuration for the evidence classification client. */
 export type EvidenceClientConfig = GatewayClientConfig;