@lucern/sdk 0.2.0-alpha.1

package/dist/lucern/packages/domain-worktrees/src/worktrees.d.ts

@@ -0,0 +1,185 @@
+type WorktreeStatus = "planning" | "active" | "paused" | "completed" | "merged" | "failed" | "archived";
+export type WorktreeRecord = {
+    worktreeId: string;
+    id: string;
+    topicId?: string;
+    title: string;
+    status?: WorktreeStatus | string;
+    branchId?: string | null;
+    objective?: string;
+    hypothesis?: string;
+    gate?: string;
+    track?: string;
+    trackPosition?: number;
+    executionBand?: number;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    targetBeliefIds?: string[];
+    targetQuestionIds?: string[];
+    questionCount?: number;
+    taskCount?: number;
+    frameworkSuggestions?: unknown[];
+    dependencySuggestions?: unknown[];
+    autoShapeApplied?: boolean;
+    proofArtifacts?: unknown[] | null;
+    staffingHint?: string | null;
+    lastReconciledAt?: number | null;
+    autoFixPolicy?: Record<string, unknown> | null;
+    lensId?: string | null;
+    createdAt?: number;
+    updatedAt?: number;
+};
+export type WorktreeListResult = {
+    worktrees: WorktreeRecord[];
+    total: number;
+};
+export type CreateWorktreeInput = {
+    title: string;
+    topicId: string;
+    objective?: string;
+    hypothesis?: string;
+    beliefIds?: string[];
+    autoShape?: boolean;
+    domainPackId?: string;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    gate?: string;
+    proofArtifacts?: unknown[];
+    staffingHint?: string;
+    lastReconciledAt?: number;
+    autoFixPolicy?: Record<string, unknown>;
+    lensId?: string;
+};
+export type ListWorktreesQuery = {
+    topicId: string;
+    status?: string;
+    limit?: number;
+};
+export type ActivateWorktreeInput = {
+    id: string;
+};
+export type MergeWorktreeInput = {
+    id: string;
+    summary?: string;
+    outcomes: Array<{
+        beliefId: string;
+        confidence: number;
+        rationale: string;
+    }>;
+};
+export type MergeWorktreeResult = {
+    worktreeId: string;
+    status: "merged";
+    beliefsScored: number;
+    failedBeliefs: Array<{
+        beliefId: string;
+        reason: string;
+    }>;
+    summary?: string;
+    mergedAt: number;
+};
+export type UpdateWorktreeTargetsInput = {
+    id: string;
+    addBeliefIds?: string[];
+    addQuestionIds?: string[];
+    removeBeliefIds?: string[];
+    removeQuestionIds?: string[];
+};
+export type UpdateWorktreeInput = {
+    id: string;
+    objective?: string;
+    hypothesis?: string;
+    rationale?: string;
+    track?: string;
+    trackPosition?: number;
+    executionBand?: number;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    gate?: string;
+    status?: string;
+    topicId?: string;
+    additionalTopicIds?: string[];
+    proofArtifacts?: unknown[];
+    staffingHint?: string;
+    lastReconciledAt?: number;
+    autoFixPolicy?: unknown;
+    lensId?: string;
+};
+type CreateWorktreePortInput = {
+    title: string;
+    topicRawId: string;
+    objective?: string;
+    hypothesis?: string;
+    beliefRawIds?: string[];
+    autoShape?: boolean;
+    domainPackId?: string;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    gate?: string;
+    proofArtifacts?: unknown[];
+    staffingHint?: string;
+    lastReconciledAt?: number;
+    autoFixPolicy?: Record<string, unknown>;
+    lensId?: string;
+};
+type UpdateWorktreeTargetsPortInput = {
+    worktreeRawId: string;
+    addBeliefRawIds?: string[];
+    addQuestionRawIds?: string[];
+    removeBeliefRawIds?: string[];
+    removeQuestionRawIds?: string[];
+};
+type UpdateWorktreeMetadataPortInput = {
+    worktreeRawId: string;
+    objective?: string;
+    hypothesis?: string;
+    rationale?: string;
+    track?: string;
+    trackPosition?: number;
+    executionBand?: number;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    gate?: string;
+    status?: string;
+    topicId?: string;
+    additionalTopicIds?: string[];
+    proofArtifacts?: unknown[];
+    staffingHint?: string;
+    lastReconciledAt?: number;
+    autoFixPolicy?: unknown;
+    lensId?: string;
+};
+export type WorktreesPort = {
+    fetchWorktree: (rawId: string) => Promise<unknown | null>;
+    listWorktreesByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    createWorktree: (input: CreateWorktreePortInput) => Promise<unknown>;
+    activateWorktree: (args: {
+        worktreeRawId: string;
+    }) => Promise<unknown>;
+    completeWorktree: (args: {
+        worktreeRawId: string;
+        summary: string;
+    }) => Promise<unknown>;
+    scoreBeliefOutcome: (args: {
+        beliefRawId: string;
+        confidence: number;
+        rationale: string;
+    }) => Promise<unknown>;
+    updateWorktreeMetadata: (input: UpdateWorktreeMetadataPortInput) => Promise<unknown>;
+    updateWorktreeTargets: (input: UpdateWorktreeTargetsPortInput) => Promise<unknown>;
+};
+export declare function createWorktree(deps: WorktreesPort, input: CreateWorktreeInput): Promise<WorktreeRecord>;
+export declare function listWorktrees(deps: WorktreesPort, query: ListWorktreesQuery): Promise<WorktreeListResult>;
+export declare function activateWorktree(deps: WorktreesPort, input: ActivateWorktreeInput): Promise<WorktreeRecord>;
+export declare function updateWorktree(deps: WorktreesPort, input: UpdateWorktreeInput): Promise<WorktreeRecord>;
+export declare function updateWorktreeTargets(deps: WorktreesPort, input: UpdateWorktreeTargetsInput): Promise<WorktreeRecord>;
+export declare function mergeWorktree(deps: WorktreesPort, input: MergeWorktreeInput): Promise<MergeWorktreeResult>;
+export {};

package/dist/lucern/packages/events/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./matching";
+export * from "./outbox";
+export * from "./types";
+export * from "./webhooks";

package/dist/lucern/packages/events/src/matching.d.ts

@@ -0,0 +1,3 @@
+export declare function eventPatternToRegExp(pattern: string): RegExp;
+export declare function matchesEventPattern(eventType: string, pattern: string): boolean;
+export declare function matchesAnyEventPattern(eventType: string, patterns: readonly string[]): boolean;

package/dist/lucern/packages/events/src/outbox.d.ts

@@ -0,0 +1,15 @@
+import { type CreateDomainEventInput, type DomainActorType, type DomainEvent, type EventCursor } from "./types";
+export declare function createEventId(): string;
+export declare function normalizeRetentionDays(value: number | undefined): number;
+export declare function buildDomainEvent(input: CreateDomainEventInput): DomainEvent;
+export declare function compareEventCursor(left: EventCursor, right: EventCursor): number;
+export declare function encodeEventCursor(cursor: EventCursor): string;
+export declare function decodeEventCursor(cursor: string | undefined): EventCursor | null;
+export declare function isAfterCursor(event: Pick<DomainEvent, "timestamp" | "eventId">, cursor: EventCursor | null): boolean;
+export declare function sortEventsByCursor<T extends Pick<DomainEvent, "timestamp" | "eventId">>(events: readonly T[]): T[];
+export declare function inferActorType(args: {
+    sessionType?: "agent" | "user";
+    authMode?: string;
+    principalType?: string;
+}): DomainActorType;
+export declare function emitDomainEvent(invokeMutation: (reference: any, args: CreateDomainEventInput) => Promise<unknown>, input: CreateDomainEventInput): Promise<unknown>;

package/dist/lucern/packages/events/src/types.d.ts

@@ -0,0 +1,151 @@
+export declare const DOMAIN_EVENT_VERSION: "1.0";
+export declare const EVENT_RETENTION_DEFAULT_DAYS = 30;
+export declare const WEBHOOK_MAX_ATTEMPTS = 5;
+export declare const WEBHOOK_RETRY_DELAYS_MS: readonly [1000, 5000, 30000, 300000];
+export declare const DOMAIN_EVENT_TYPES: readonly ["belief.created", "belief.forked", "belief.confidence_updated", "belief.archived", "belief.refined", "belief.contract_created", "belief.contract_evaluated", "belief.lineage_queried", "evidence.created", "evidence.linked", "evidence.search_executed", "question.created", "question.answered", "question.refined", "question.status_updated", "question.archived", "edge.created", "contradiction.flagged", "worktree.created", "worktree.activated", "worktree.merged", "worktree.targets_updated", "worktree.metadata_updated", "topic.created", "topic.updated", "topic.archived", "task.created", "task.completed", "task.updated", "ontology.bound", "context.compiled", "identity.key_created", "identity.key_rotated", "identity.key_revoked", "webhook.test"];
+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;
+    actorId: string;
+    actorType: DomainActorType;
+    data: DomainEventData;
+    correlationId?: string;
+    expiresAt: number;
+};
+export type CreateDomainEventInput = {
+    eventId?: string;
+    timestamp?: number;
+    tenantId?: string;
+    workspaceId?: string;
+    topicId: string;
+    type: DomainEventType | string;
+    resourceId: string;
+    resourceType: DomainResourceType | string;
+    actorId: string;
+    actorType: DomainActorType;
+    data?: DomainEventData;
+    correlationId?: string;
+    retentionDays?: number;
+};
+export type EventCursor = {
+    timestamp: number;
+    eventId: string;
+};
+export type EventListQuery = {
+    topicId?: string;
+    after?: string;
+    types?: string[];
+    startTime?: number;
+    endTime?: number;
+    limit?: number;
+};
+export type 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[];
+    active: boolean;
+    secretConfigured: boolean;
+    createdAt: number;
+    updatedAt: number;
+    createdBy: string;
+    updatedBy: string;
+    lastDeliveryAt?: number;
+    lastSuccessfulDeliveryAt?: number;
+};
+export type WebhookCreateInput = {
+    url: string;
+    events: string[];
+    secret: string;
+    topicId?: string;
+    active?: boolean;
+};
+export type WebhookUpdateInput = {
+    url?: string;
+    events?: string[];
+    secret?: string;
+    topicId?: string | null;
+    active?: boolean;
+};
+export type WebhookDeliveryStatus = "pending" | "delivering" | "succeeded" | "failed" | "dead_letter";
+export type WebhookDeliveryRecord = {
+    id: string;
+    deliveryId: string;
+    webhookId: string;
+    eventId: string;
+    eventType: string;
+    topicId: string;
+    status: WebhookDeliveryStatus;
+    attemptCount: number;
+    maxAttempts: number;
+    nextAttemptAt?: number;
+    lastAttemptAt?: number;
+    lastStatusCode?: number;
+    lastError?: string;
+    deliveredAt?: number;
+    createdAt: number;
+    updatedAt: number;
+};
+export type WebhookDeliveryAttemptRecord = {
+    id: string;
+    attemptId: string;
+    deliveryId: string;
+    webhookId: string;
+    eventId: string;
+    eventType: string;
+    attemptNumber: number;
+    status: "succeeded" | "failed";
+    statusCode?: number;
+    error?: string;
+    responseBody?: string;
+    durationMs?: number;
+    createdAt: number;
+};
+export type WebhookDeliveriesResult = {
+    deliveries: Array<WebhookDeliveryRecord & {
+        attempts?: WebhookDeliveryAttemptRecord[];
+    }>;
+};
+export type WebhookHealthResult = {
+    webhookId: string;
+    totalAttempts: number;
+    successfulAttempts: number;
+    failedAttempts: number;
+    successRate: number;
+    pendingDeliveries: number;
+    deadLetterDeliveries: number;
+    lastDeliveryAt?: number;
+    lastSuccessfulDeliveryAt?: number;
+};
+export type WebhookTestResult = {
+    webhookId: string;
+    deliveryId: string;
+    status: WebhookDeliveryStatus;
+    attempts: number;
+};
+export type ReplayEventsInput = EventListQuery & {
+    webhookId?: string;
+};
+export type ReplayEventsResult = EventListResult & {
+    replayedDeliveries?: number;
+    replayedWebhookId?: string;
+};

package/dist/lucern/packages/events/src/webhooks.d.ts

@@ -0,0 +1,9 @@
+import { type WebhookDeliveryStatus, type WebhookRecord } from "./types";
+export declare function assertValidWebhookUrl(url: string): string;
+export declare function normalizeWebhookPatterns(patterns: readonly string[]): string[];
+export declare function assertValidWebhookSecret(secret: string): string;
+export declare function computeWebhookSignature(payload: string, secret: string): Promise<string>;
+export declare function nextDeliveryAttemptAt(currentAttemptCount: number, now?: number): number | undefined;
+export declare function resolveDeliveryFailureStatus(attemptCount: number): WebhookDeliveryStatus;
+export declare function sanitizeWebhookRecord(value: Record<string, unknown>): WebhookRecord;
+export declare function truncateWebhookResponseBody(responseBody: string | undefined, maxLength?: number): string | undefined;

package/dist/lucern/packages/sdk-typescript/src/facade/beliefs.d.ts

@@ -0,0 +1,15 @@
+import { type BeliefsClientCoreConfig } from "@/lucern/packages/client-core/src/beliefs";
+export type BeliefsFacadeConfig = BeliefsClientCoreConfig;
+export declare function createBeliefsFacade(config?: BeliefsFacadeConfig): {
+    create(input: Parameters<(input: import("..").CreateBeliefInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").CreateBeliefInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateResponse>;
+    get(id: string): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsGetResponse>;
+    list(query: Parameters<(query: import("..").ListBeliefsQuery) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsListResponse>;
+    refine(id: string, input: Parameters<(id: string, input: Omit<import("..").BeliefRefineInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsRefineResponse>>[1], idempotencyKey?: Parameters<(id: string, input: Omit<import("..").BeliefRefineInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsRefineResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsRefineResponse>;
+    fork(id: string, input: Parameters<(id: string, input: Omit<import("..").ForkBeliefInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsForkResponse>>[1], idempotencyKey?: Parameters<(id: string, input: Omit<import("..").ForkBeliefInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsForkResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsForkResponse>;
+    updateConfidence(id: string, input: Parameters<(id: string, input: Omit<import("..").UpdateBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsUpdateConfidenceResponse>>[1], idempotencyKey?: Parameters<(id: string, input: Omit<import("..").UpdateBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsUpdateConfidenceResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsUpdateConfidenceResponse>;
+    archive(id: string, input?: Parameters<(id: string, input?: Omit<import("..").ArchiveBeliefInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsArchiveResponse>>[1], idempotencyKey?: Parameters<(id: string, input?: Omit<import("..").ArchiveBeliefInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsArchiveResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsArchiveResponse>;
+    lineage(id: string): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsLineageResponse>;
+    confidenceHistory(id: string): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsConfidenceHistoryResponse>;
+    createContract(id: string, input: Parameters<(id: string, input: import("..").BeliefContractCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>>[1], idempotencyKey?: Parameters<(id: string, input: import("..").BeliefContractCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>;
+    bisect(id: string, input: Parameters<(id: string, input: Omit<import("..").BisectBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>>[1], idempotencyKey?: Parameters<(id: string, input: Omit<import("..").BisectBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/context.d.ts

@@ -0,0 +1,12 @@
+import { type CompileContextInput, type ContextClientRequest } from "../../../client-core/src/context";
+import type { PublicCompiledContext } from "../../../domain-context/src";
+export type ContextFacadeTransport = {
+    request<T>(request: ContextClientRequest): Promise<T>;
+};
+export type ContextFacadeConfig = {
+    transport: ContextFacadeTransport;
+};
+export declare function createContextFacade(config: ContextFacadeConfig): {
+    compile(topicId: string, input?: CompileContextInput): Promise<PublicCompiledContext>;
+};
+export type { CompileContextInput, PublicCompiledContext };

package/dist/lucern/packages/sdk-typescript/src/facade/contradictions.d.ts

@@ -0,0 +1,7 @@
+import { type ContradictionsClientCoreConfig } from "@/lucern/packages/client-core/src/contradictions";
+export type ContradictionsFacadeConfig = ContradictionsClientCoreConfig;
+export declare function createContradictionsFacade(config?: ContradictionsFacadeConfig): {
+    flag(input: Parameters<(input: import("..").FlagContradictionInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsFlagResponse>>[0], idempotencyKey?: Parameters<(input: import("..").FlagContradictionInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsFlagResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsFlagResponse>;
+    list(query: Parameters<(query: import("..").ListContradictionsQuery) => Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsListResponse>;
+    get(id: string): Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsGetResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/edges.d.ts

@@ -0,0 +1,7 @@
+import { type EdgesClientCoreConfig } from "@/lucern/packages/client-core/src/edges";
+export type EdgesFacadeConfig = EdgesClientCoreConfig;
+export declare function createEdgesFacade(config?: EdgesFacadeConfig): {
+    create(input: Parameters<(input: import("..").CreateEdgeInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/edges").EdgesCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").CreateEdgeInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/edges").EdgesCreateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/edges").EdgesCreateResponse>;
+    list(query: Parameters<(query: import("..").ListEdgesQuery) => Promise<import("@/lucern/packages/client-core/src/edges").EdgesListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/edges").EdgesListResponse>;
+    traverse(input: Parameters<(input: import("..").TraverseEdgesInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/edges").EdgesTraverseResponse>>[0], idempotencyKey?: Parameters<(input: import("..").TraverseEdgesInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/edges").EdgesTraverseResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/edges").EdgesTraverseResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/events.d.ts

@@ -0,0 +1,6 @@
+import { type EventsClientCoreConfig } from "@/lucern/packages/client-core/src/events";
+export type EventsFacadeConfig = EventsClientCoreConfig;
+export declare function createEventsFacade(config?: EventsFacadeConfig): {
+    list(query: Parameters<(query?: import("..").EventListQuery) => Promise<import("@/lucern/packages/client-core/src/events").EventsListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/events").EventsListResponse>;
+    replay(input: Parameters<(input: import("..").ReplayEventsInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/events").EventsReplayResponse>>[0], idempotencyKey?: Parameters<(input: import("..").ReplayEventsInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/events").EventsReplayResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/events").EventsReplayResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/evidence.d.ts

@@ -0,0 +1,21 @@
+import { type EvidenceClientCoreConfig } from "@/lucern/packages/client-core/src/evidence";
+export type EvidenceFacadeConfig = EvidenceClientCoreConfig;
+export declare function createEvidenceFacade(config?: EvidenceFacadeConfig): {
+    create(input: Parameters<(input: import("..").CreateEvidenceInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").CreateEvidenceInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceCreateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceCreateResponse>;
+    get(id: string): Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceGetResponse>;
+    list(query: Parameters<(query: import("..").ListEvidenceQuery) => Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceListResponse>;
+    link(input: Parameters<(input: {
+        evidenceId: string;
+        targetId: string;
+        targetType?: "belief" | "question";
+        weight?: number;
+        rationale?: string;
+    }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceLinkResponse>>[0], idempotencyKey?: Parameters<(input: {
+        evidenceId: string;
+        targetId: string;
+        targetType?: "belief" | "question";
+        weight?: number;
+        rationale?: string;
+    }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceLinkResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceLinkResponse>;
+    search(query: Parameters<(query: import("..").SearchEvidenceQuery, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceSearchResponse>>[0], idempotencyKey?: Parameters<(query: import("..").SearchEvidenceQuery, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceSearchResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/evidence").EvidenceSearchResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/graph.d.ts

@@ -0,0 +1,10 @@
+import { type GraphClientCoreConfig } from "@/lucern/packages/client-core/src/graph";
+export type GraphFacadeConfig = GraphClientCoreConfig;
+export declare function createGraphFacade(config?: GraphFacadeConfig): {
+    neighborhood(input: Parameters<(input: import("..").GraphNeighborhoodInput) => Promise<import("@/lucern/packages/client-core/src/graph").GraphNeighborhoodResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/graph").GraphNeighborhoodResponse>;
+    traverse(input: Parameters<(input: import("..").GraphTraverseInput) => Promise<import("@/lucern/packages/client-core/src/graph").GraphTraverseResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/graph").GraphTraverseResponse>;
+    analyze(input: Parameters<(input: import("..").GraphAnalyzeInput) => Promise<import("@/lucern/packages/client-core/src/graph").GraphAnalyzeResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/graph").GraphAnalyzeResponse>;
+    bias(input: Parameters<(input: import("..").GraphBiasInput) => Promise<import("@/lucern/packages/client-core/src/graph").GraphBiasResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/graph").GraphBiasResponse>;
+    gaps(input: Parameters<(input: import("..").GraphGapsInput) => Promise<import("@/lucern/packages/client-core/src/graph").GraphGapsResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/graph").GraphGapsResponse>;
+    falsify(input: Parameters<(input: import("..").GraphFalsifyInput) => Promise<import("@/lucern/packages/client-core/src/graph").GraphFalsifyResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/graph").GraphFalsifyResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/identity.d.ts

@@ -0,0 +1,5 @@
+import { type IdentityClientCoreConfig } from "@/lucern/packages/client-core/src/identity";
+export type IdentityFacadeConfig = IdentityClientCoreConfig;
+export declare function createIdentityFacade(config?: IdentityFacadeConfig): {
+    whoami(): Promise<import("@/packages/sdk/src/identityClient").IdentityWhoamiResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/ontologies.d.ts

@@ -0,0 +1,8 @@
+import { type OntologiesClientCoreConfig } from "@/lucern/packages/client-core/src/ontologies";
+export type OntologiesFacadeConfig = OntologiesClientCoreConfig;
+export declare function createOntologiesFacade(config?: OntologiesFacadeConfig): {
+    get(id: string): Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesGetResponse>;
+    list(query?: Parameters<(query?: import("..").OntologyListQuery) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesListResponse>;
+    bind(input: Parameters<(input: import("..").BindOntologyInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[0], idempotencyKey?: Parameters<(input: import("..").BindOntologyInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>;
+    match(input: Parameters<(input: import("..").OntologyMatchInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[0], idempotencyKey?: Parameters<(input: import("..").OntologyMatchInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/questions.d.ts

@@ -0,0 +1,39 @@
+import { type QuestionsClientCoreConfig } from "@/lucern/packages/client-core/src/questions";
+export type QuestionsFacadeConfig = QuestionsClientCoreConfig;
+export declare function createQuestionsFacade(config?: QuestionsFacadeConfig): {
+    create(input: Parameters<(input: import("..").CreateQuestionInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").CreateQuestionInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsCreateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/questions").QuestionsCreateResponse>;
+    get(id: string): Promise<import("@/lucern/packages/client-core/src/questions").QuestionsGetResponse>;
+    list(query: Parameters<(query: import("..").ListQuestionsQuery) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/questions").QuestionsListResponse>;
+    answer(id: string, input: Parameters<(id: string, input: {
+        text: string;
+        confidence?: string;
+        evidenceIds?: string[];
+        rationale?: string;
+    }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsAnswerResponse>>[1], idempotencyKey?: Parameters<(id: string, input: {
+        text: string;
+        confidence?: string;
+        evidenceIds?: string[];
+        rationale?: string;
+    }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsAnswerResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/questions").QuestionsAnswerResponse>;
+    refine(id: string, input: Parameters<(id: string, input: {
+        text: string;
+        rationale?: string;
+    }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsRefineResponse>>[1], idempotencyKey?: Parameters<(id: string, input: {
+        text: string;
+        rationale?: string;
+    }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsRefineResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/questions").QuestionsRefineResponse>;
+    archive(id: string, input?: Parameters<(id: string, input?: {
+        reason?: string;
+        rationale?: string;
+    }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsArchiveResponse>>[1], idempotencyKey?: Parameters<(id: string, input?: {
+        reason?: string;
+        rationale?: string;
+    }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsArchiveResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/questions").QuestionsArchiveResponse>;
+    updateStatus(id: string, input: Parameters<(id: string, input: {
+        status: string;
+        rationale?: string;
+    }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsUpdateStatusResponse>>[1], idempotencyKey?: Parameters<(id: string, input: {
+        status: string;
+        rationale?: string;
+    }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/questions").QuestionsUpdateStatusResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/questions").QuestionsUpdateStatusResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/search.d.ts

@@ -0,0 +1,5 @@
+import { type SearchClientCoreConfig } from "@/lucern/packages/client-core/src/search";
+export type SearchFacadeConfig = SearchClientCoreConfig;
+export declare function createSearchFacade(config?: SearchFacadeConfig): {
+    query(input: Parameters<(input: import("..").SearchInput) => Promise<import("@/lucern/packages/client-core/src/search").SearchResourcesResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/search").SearchResourcesResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/tasks.d.ts

@@ -0,0 +1,8 @@
+import { type TasksClientCoreConfig } from "@/lucern/packages/client-core/src/tasks";
+export type TasksFacadeConfig = TasksClientCoreConfig;
+export declare function createTasksFacade(config?: TasksFacadeConfig): {
+    create(input: Parameters<(input: import("..").CreateTaskInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/tasks").TasksCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").CreateTaskInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/tasks").TasksCreateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/tasks").TasksCreateResponse>;
+    update(input: Parameters<(input: import("..").UpdateTaskInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/tasks").TasksUpdateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").UpdateTaskInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/tasks").TasksUpdateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/tasks").TasksUpdateResponse>;
+    complete(input: Parameters<(input: import("..").CompleteTaskInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/tasks").TasksCompleteResponse>>[0], idempotencyKey?: Parameters<(input: import("..").CompleteTaskInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/tasks").TasksCompleteResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/tasks").TasksCompleteResponse>;
+    list(query: Parameters<(query: import("..").ListTasksQuery) => Promise<import("@/lucern/packages/client-core/src/tasks").TasksListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/tasks").TasksListResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/topics.d.ts

@@ -0,0 +1,10 @@
+import { type TopicsClientCoreConfig } from "@/lucern/packages/client-core/src/topics";
+export type TopicsFacadeConfig = TopicsClientCoreConfig;
+export declare function createTopicsFacade(config?: TopicsFacadeConfig): {
+    create(input: Parameters<(input: import("..").CreateTopicInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/topics").TopicsCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").CreateTopicInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/topics").TopicsCreateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsCreateResponse>;
+    get(id: string): Promise<import("@/lucern/packages/client-core/src/topics").TopicsGetResponse>;
+    list(query?: Parameters<(query?: import("..").ListTopicsQuery) => Promise<import("@/lucern/packages/client-core/src/topics").TopicsListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsListResponse>;
+    update(input: Parameters<(input: import("..").UpdateTopicInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/topics").TopicsUpdateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").UpdateTopicInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/topics").TopicsUpdateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsUpdateResponse>;
+    tree(input: Parameters<(input: import("..").GetTopicTreeInput) => Promise<import("@/lucern/packages/client-core/src/topics").TopicsTreeResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsTreeResponse>;
+    coverage(input: Parameters<(input: import("..").GetTopicCoverageInput) => Promise<import("@/lucern/packages/client-core/src/topics").TopicsCoverageResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsCoverageResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/webhooks.d.ts

@@ -0,0 +1,16 @@
+import { type WebhooksClientCoreConfig } from "@/lucern/packages/client-core/src/webhooks";
+export type WebhooksFacadeConfig = WebhooksClientCoreConfig;
+export declare function createWebhooksFacade(config?: WebhooksFacadeConfig): {
+    create(input: Parameters<(input: import("..").WebhookCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").WebhookCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksCreateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksCreateResponse>;
+    list(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>;
+    get(id: string): Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksGetResponse>;
+    update(id: string, input: Parameters<(id: string, input: import("..").WebhookUpdateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksUpdateResponse>>[1], idempotencyKey?: Parameters<(id: string, input: import("..").WebhookUpdateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksUpdateResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksUpdateResponse>;
+    delete(id: string, idempotencyKey?: Parameters<(id: string, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksDeleteResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksDeleteResponse>;
+    test(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>;
+    deliveries(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>;
+    health(id: string): Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksHealthResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/worktrees.d.ts

@@ -0,0 +1,10 @@
+import { type WorktreesClientCoreConfig } from "@/lucern/packages/client-core/src/worktrees";
+export type WorktreesFacadeConfig = WorktreesClientCoreConfig;
+export declare function createWorktreesFacade(config?: WorktreesFacadeConfig): {
+    create(input: Parameters<(input: import("..").CreateWorktreeInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").CreateWorktreeInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesCreateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesCreateResponse>;
+    list(query: Parameters<(query: import("..").ListWorktreesQuery) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesListResponse>;
+    activate(input: Parameters<(input: import("..").ActivateWorktreeInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesActivateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").ActivateWorktreeInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesActivateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesActivateResponse>;
+    update(input: Parameters<(input: import("..").UpdateWorktreeInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesUpdateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").UpdateWorktreeInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesUpdateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesUpdateResponse>;
+    merge(input: Parameters<(input: import("..").MergeWorktreeInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesMergeResponse>>[0], idempotencyKey?: Parameters<(input: import("..").MergeWorktreeInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesMergeResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesMergeResponse>;
+    updateTargets(input: Parameters<(input: import("..").UpdateWorktreeTargetsInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesTargetsResponse>>[0], idempotencyKey?: Parameters<(input: import("..").UpdateWorktreeTargetsInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesTargetsResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesTargetsResponse>;
+};