@aletheia-dev/api-client 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2215 @@
+import { z } from 'zod';
+import * as _aletheia_dev_core from '@aletheia-dev/core';
+import { TenantSettings, AuditFilter, AuditEvent, AuditExportFormat, DefinitionKind, DefinitionVersionSummary, DefinitionDiff, ApprovalCommentInput, DefinitionApproval, StepTypeDescription, FieldTypeDescription, UpsertCollectionFlowInput, UpsertWorkflowDefinitionInput, CaseStatus, CasePriority, CaseSlaState, CaseSort, SortOrder, DecideCaseInput, AssignCaseInput, CloseCaseInput, CaseNoteInput, UpsertCaseQueueInput, CaseQueue, CaseView, CaseNote, DirectoryUser, DocumentStatus, CreateDocumentInput, DocumentUploadTicket, Document, DocumentDownload, StartWorkflowRunInput, WorkflowRun, AddListEntriesInput, CreateSubjectInput, Subject, SubjectListQuery, TimelineQuery, TimelineEntry, CreateSubmissionInput, SaveSubmissionInput, CollectionSubmission, IngestEventsInput, IngestEventsResult, Event, StartBacktestInput, Backtest, Decision, PluginDefinition, ConfigurePluginInput, PluginInvocation, List, UpsertListInput, ListEntry, ListImportResult, RemoveListEntriesInput, UpsertRuleDefinitionInput, UpsertRuleSetInput } from '@aletheia-dev/core';
+export { ActorType, AddListEntriesInput, AggregationPolicy, ApprovalCommentInput, ApprovalDecision, AssignCaseInput, AuditEvent, AuditExportFormat, AuditFilter, Backtest, BacktestProgress, BacktestSample, BacktestSampleFailure, BacktestStatus, BacktestSummary, Case, CaseFilter, CaseNote, CaseNoteInput, CasePriority, CaseQueue, CaseSlaState, CaseSort, CaseStatus, CaseView, CloseCaseInput, Condition, ConditionOp, CreateDocumentInput, DEFINITION_PATHS, DOCUMENT_CONTENT_TYPES, DOCUMENT_MAX_BYTES, DOCUMENT_OPEN_STATUSES, DefinitionApproval, DefinitionDiff, DefinitionIssue, DefinitionKind, DefinitionVersionSummary, DiffChange, DiffOp, DirectoryUser, Document, DocumentContentType, DocumentDownload, DocumentScan, DocumentStatus, DocumentUploadTicket, Event, EventKey, FieldTypeDescription, FileFieldValue, FormUiHints, IngestEventsInput, IngestEventsResult, IssueSeverity, List, ListEntry, ListImportResult, ListKind, NewEvent, NewListEntry, RemoveListEntriesInput, RuleSetBody, RuleSetDefinition, RuleSetRule, RuleSetUseCase, ScoreBand, ScoreClamp, SortOrder, StartBacktestInput, StepTypeDescription, Subject, SubjectKind, SubjectListQuery, SubjectStatus, TenantSettings, TimelineEntry, TimelineKind, TimelineQuery, UpsertCaseQueueInput, UpsertListInput, UpsertRuleSetInput, ValidationReport, WebOrigin, bandFor, caseSlaState, normalizeListValue } from '@aletheia-dev/core';
+
+/** Shape of every non-2xx body returned by the API. */
+interface ApiErrorBody {
+    error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+}
+/** Thrown by the client for any non-2xx response. `status` is the HTTP status. */
+declare class ApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    constructor(message: string, status: number, code: string, details?: unknown | undefined);
+    /** Builds an ApiError from a response status and its (possibly non-JSON) body. */
+    static fromResponse(status: number, statusText: string, body: unknown): ApiError;
+}
+declare function isApiErrorBody(value: unknown): value is ApiErrorBody;
+declare function isApiError(value: unknown): value is ApiError;
+/** True for a 401 `unauthenticated` response: the caller must (re-)sign in. */
+declare function isUnauthenticated(value: unknown): value is ApiError;
+/** Permission or provisioning failures: the caller is signed in but may not act. */
+declare const FORBIDDEN_CODES: readonly ["forbidden", "tenant_not_provisioned"];
+/** True for a 403 response (`forbidden` or `tenant_not_provisioned`). */
+declare function isForbidden(value: unknown): value is ApiError;
+/** True when the signed-in organization has no tenant in Aletheia yet. */
+declare function isTenantNotProvisioned(value: unknown): value is ApiError;
+
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+/** Returns the current bearer token, or nothing when the caller is not signed in. */
+type AccessTokenProvider = () => Promise<string | undefined> | string | undefined;
+interface HttpOptions {
+    baseUrl: string;
+    getAccessToken: AccessTokenProvider;
+    fetch: FetchLike;
+}
+/** One query value; arrays are serialised as repeated parameters (`status=a&status=b`). */
+type QueryValue = string | number | boolean | undefined | null | readonly string[];
+type Query = Record<string, QueryValue>;
+/** A body sent verbatim with an explicit content type (e.g. a CSV upload). */
+interface RawBody {
+    content: string;
+    contentType: string;
+}
+interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    query?: Query;
+    /** JSON-encoded request body. Ignored when `raw` is set. */
+    body?: unknown;
+    /** Raw text body; takes precedence over `body`. */
+    raw?: RawBody;
+}
+/** Minimal transport: sets the bearer header, encodes query & body (JSON or raw text), maps errors. */
+declare class Http {
+    private readonly options;
+    constructor(options: HttpOptions);
+    request(path: string, options?: RequestOptions): Promise<unknown>;
+    /** Requests and parses the body with `schema` (dates are coerced by the core schemas). */
+    parsed<T extends z.ZodType>(schema: T, path: string, options?: RequestOptions): Promise<z.output<T>>;
+}
+
+/** Tenant-level settings (`/tenants/me/settings`, `tenants:settings`). */
+interface TenantsClient {
+    getSettings: () => Promise<TenantSettings>;
+    /** Replaces the whole settings object; the API rejects malformed origins with a 400. */
+    /** Full replace; omitted sections (e.g. `cases`) fall back to their defaults. */
+    updateSettings: (body: z.input<typeof TenantSettings>) => Promise<TenantSettings>;
+}
+
+/**
+ * Filters of `GET /audit-events` and its export. `action` is a prefix match (`case.` matches
+ * `case.decided`); `from`/`to` bound `occurredAt` and are sent as ISO strings.
+ */
+type AuditFilterQuery = Omit<AuditFilter, 'from' | 'to'> & {
+    from?: Date | string;
+    to?: Date | string;
+};
+/** `GET /audit-events` query: the filters plus offset paging (newest first). */
+type AuditListQuery = AuditFilterQuery & {
+    limit?: number;
+    offset?: number;
+};
+interface AuditClient {
+    /** Audit events matching `query`, newest first (`audit:read`). */
+    list: (query?: AuditListQuery) => Promise<AuditEvent[]>;
+    /** Absolute URL of the export endpoint for a filter (the request still needs the bearer token). */
+    exportUrl: (format: AuditExportFormat, filter?: AuditFilterQuery) => string;
+    /** Downloads the filtered export with the bearer token; the last line is the manifest. */
+    export: (format: AuditExportFormat, filter?: AuditFilterQuery) => Promise<Blob>;
+}
+/** Flattens the filter into transport parameters (empty values are dropped by `buildUrl`). */
+declare function auditFilterParams(filter?: AuditFilterQuery): Query;
+/** Outcome of checking an export against its trailing manifest. */
+interface ExportVerification {
+    /** True when a manifest was found and its digest matches the body. */
+    ok: boolean;
+    /** Row count stated by the manifest (0 when there is none). */
+    rows: number;
+    /** Digest stated by the manifest, when present. */
+    expected?: string;
+    /** SHA-256 (hex) of the body before the manifest line. */
+    actual: string;
+}
+/**
+ * Checks an exported file against its manifest (the last line: `# sha256=<hex> rows=<n>` for
+ * CSV, `{"_manifest":{"sha256","rows"}}` for JSONL). The digest covers every byte before the
+ * manifest line, including the newline that ends the last data row, as the server hashes it.
+ */
+declare function verifyExport(text: string, format: AuditExportFormat): Promise<ExportVerification>;
+
+/** Response of `POST .../approve` and `.../reject`: the decided approval and the definition. */
+declare const ApprovalOutcome: z.ZodObject<{
+    approval: z.ZodObject<{
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        kind: z.ZodEnum<{
+            workflow: "workflow";
+            rule: "rule";
+            rule_set: "rule_set";
+            collection_flow: "collection_flow";
+        }>;
+        key: z.ZodString;
+        version: z.ZodNumber;
+        requestedBy: z.ZodString;
+        requestedAt: z.ZodCoercedDate<unknown>;
+        comment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        decidedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        decidedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        decision: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            rejected: "rejected";
+            approved: "approved";
+        }>>>;
+        decisionComment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    definition: z.ZodUnknown;
+}, z.core.$strip>;
+type ApprovalOutcome = z.infer<typeof ApprovalOutcome>;
+/** Version pair of a diff; `from` defaults to the published version, `to` to the latest. */
+interface DiffQuery {
+    from?: number;
+    to?: number;
+}
+interface ApprovalListQuery {
+    kind?: DefinitionKind;
+}
+interface GovernanceClient {
+    /** Every version of a definition, with status, author and approval (`definitions:read`). */
+    versions: (kind: DefinitionKind, key: string) => Promise<DefinitionVersionSummary[]>;
+    /** The full definition entity of one version, e.g. to restore it as a draft. */
+    getVersion: (kind: DefinitionKind, key: string, version: number) => Promise<unknown>;
+    /** Structured diff between two versions with a readable summary per change. */
+    diff: (kind: DefinitionKind, key: string, query?: DiffQuery) => Promise<DefinitionDiff>;
+    /** Moves a draft to `pending_approval` (`definitions:write`). */
+    requestApproval: (kind: DefinitionKind, key: string, version: number, body?: ApprovalCommentInput) => Promise<DefinitionApproval>;
+    /** Approves and publishes a pending version (`definitions:approve`). */
+    approve: (kind: DefinitionKind, key: string, version: number, body?: ApprovalCommentInput) => Promise<ApprovalOutcome>;
+    /** Sends a pending version back to draft (`definitions:approve`). */
+    reject: (kind: DefinitionKind, key: string, version: number, body?: ApprovalCommentInput) => Promise<ApprovalOutcome>;
+    approvals: {
+        /** Approvals awaiting a decision, optionally for one definition kind. */
+        listOpen: (query?: ApprovalListQuery) => Promise<DefinitionApproval[]>;
+    };
+}
+
+/** Schema endpoints that drive the builder's forms (`definitions:read`). */
+interface BuilderClient {
+    /** Every workflow step type with its config JSON Schema, ui hints and data paths. */
+    stepTypes: () => Promise<StepTypeDescription[]>;
+    /** Every collection-flow field type with its options and value schemas. */
+    fieldTypes: () => Promise<FieldTypeDescription[]>;
+}
+type ValidateWorkflowBody = z.input<typeof UpsertWorkflowDefinitionInput>;
+type ValidateCollectionFlowBody = z.input<typeof UpsertCollectionFlowInput>;
+
+type DecideCaseBody = z.input<typeof DecideCaseInput>;
+type AssignCaseBody = z.input<typeof AssignCaseInput>;
+type CloseCaseBody = z.input<typeof CloseCaseInput>;
+type CaseNoteBody = z.input<typeof CaseNoteInput>;
+/** Body of `POST/PUT /case-queues`; `filter`, `sort`, `order` and `position` have defaults. */
+type UpsertCaseQueueBody = z.input<typeof UpsertCaseQueueInput>;
+/**
+ * Filters of `GET /cases`. Array filters are sent as repeated parameters
+ * (`status=open&status=in_review`); a single value is accepted for convenience.
+ * `assignee` is `me`, `unassigned` or a directory user id.
+ */
+type CaseListQuery = {
+    status?: CaseStatus | CaseStatus[];
+    priority?: CasePriority | CasePriority[];
+    assignee?: string;
+    type?: string;
+    subjectId?: string;
+    slaState?: CaseSlaState | CaseSlaState[];
+    dueBefore?: Date | string;
+    search?: string;
+    sort?: CaseSort;
+    order?: SortOrder;
+    limit?: number;
+    offset?: number;
+};
+type UserListQuery = {
+    /** Only users holding this role (e.g. `analyst`, `admin`). */
+    role?: string;
+};
+declare const CaseDetail: z.ZodObject<{
+    case: z.ZodObject<{
+        createdAt: z.ZodCoercedDate<unknown>;
+        updatedAt: z.ZodCoercedDate<unknown>;
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        subjectId: z.ZodGUID;
+        workflowRunId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        type: z.ZodString;
+        status: z.ZodEnum<{
+            closed: "closed";
+            open: "open";
+            in_review: "in_review";
+            decided: "decided";
+        }>;
+        priority: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        assigneeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        decisionId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        dueAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        slaBreachedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        firstResponseAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        decidedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        closedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        closedReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        slaState: z.ZodEnum<{
+            none: "none";
+            ok: "ok";
+            due_soon: "due_soon";
+            breached: "breached";
+        }>;
+    }, z.core.$strip>;
+    subject: z.ZodObject<{
+        createdAt: z.ZodCoercedDate<unknown>;
+        updatedAt: z.ZodCoercedDate<unknown>;
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        kind: z.ZodEnum<{
+            user: "user";
+            merchant: "merchant";
+            seller: "seller";
+        }>;
+        externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        status: z.ZodEnum<{
+            active: "active";
+            blocked: "blocked";
+            closed: "closed";
+        }>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        riskScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        tags: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    run: z.ZodNullable<z.ZodObject<{
+        createdAt: z.ZodCoercedDate<unknown>;
+        updatedAt: z.ZodCoercedDate<unknown>;
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        definitionId: z.ZodGUID;
+        definitionKey: z.ZodString;
+        definitionVersion: z.ZodNumber;
+        subjectId: z.ZodGUID;
+        temporalWorkflowId: z.ZodString;
+        temporalRunId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        status: z.ZodEnum<{
+            running: "running";
+            waiting_collection: "waiting_collection";
+            waiting_manual: "waiting_manual";
+            waiting_callback: "waiting_callback";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>;
+        currentStepId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        decisionId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        startedAt: z.ZodCoercedDate<unknown>;
+        finishedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    }, z.core.$strip>>;
+    decisions: z.ZodArray<z.ZodObject<{
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        subjectId: z.ZodGUID;
+        workflowRunId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        caseId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        outcome: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            manual_review: "manual_review";
+        }>;
+        riskScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        reasons: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            ruleKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        source: z.ZodEnum<{
+            automated: "automated";
+            manual: "manual";
+        }>;
+        decidedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        ruleResults: z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+            ruleKey: z.ZodString;
+            ruleVersion: z.ZodNumber;
+            severity: z.ZodEnum<{
+                info: "info";
+                warn: "warn";
+                block: "block";
+            }>;
+            weight: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            outcome: z.ZodEnum<{
+                error: "error";
+                pass: "pass";
+                fail: "fail";
+                skipped: "skipped";
+            }>;
+            score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            reasons: z.ZodArray<z.ZodString>;
+            details: z.ZodOptional<z.ZodUnknown>;
+            durationMs: z.ZodNumber;
+            shadow: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        ruleSetKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        ruleSetVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        createdAt: z.ZodCoercedDate<unknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type CaseDetail = z.infer<typeof CaseDetail>;
+declare const DecideCaseResult: z.ZodObject<{
+    case: z.ZodObject<{
+        createdAt: z.ZodCoercedDate<unknown>;
+        updatedAt: z.ZodCoercedDate<unknown>;
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        subjectId: z.ZodGUID;
+        workflowRunId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        type: z.ZodString;
+        status: z.ZodEnum<{
+            closed: "closed";
+            open: "open";
+            in_review: "in_review";
+            decided: "decided";
+        }>;
+        priority: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        assigneeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        decisionId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        dueAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        slaBreachedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        firstResponseAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        decidedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        closedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        closedReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    decision: z.ZodObject<{
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        subjectId: z.ZodGUID;
+        workflowRunId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        caseId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        outcome: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            manual_review: "manual_review";
+        }>;
+        riskScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        reasons: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            ruleKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        source: z.ZodEnum<{
+            automated: "automated";
+            manual: "manual";
+        }>;
+        decidedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        ruleResults: z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+            ruleKey: z.ZodString;
+            ruleVersion: z.ZodNumber;
+            severity: z.ZodEnum<{
+                info: "info";
+                warn: "warn";
+                block: "block";
+            }>;
+            weight: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            outcome: z.ZodEnum<{
+                error: "error";
+                pass: "pass";
+                fail: "fail";
+                skipped: "skipped";
+            }>;
+            score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            reasons: z.ZodArray<z.ZodString>;
+            details: z.ZodOptional<z.ZodUnknown>;
+            durationMs: z.ZodNumber;
+            shadow: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        ruleSetKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        ruleSetVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        createdAt: z.ZodCoercedDate<unknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type DecideCaseResult = z.infer<typeof DecideCaseResult>;
+/** One row of `GET /case-queues/counts`: how many cases match the queue's filter right now. */
+declare const CaseQueueCount: z.ZodObject<{
+    queueId: z.ZodString;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+type CaseQueueCount = z.infer<typeof CaseQueueCount>;
+/** Flattens a `CaseListQuery` into transport parameters; arrays repeat, dates become ISO. */
+declare function caseListParams(query: CaseListQuery): Query;
+declare function casesDomain(http: Http): {
+    /** Cases matching `query`, in the requested order (`createdAt` desc by default). */
+    list: (query?: CaseListQuery) => Promise<CaseView[]>;
+    get: (id: string) => Promise<CaseDetail>;
+    decide: (id: string, body: DecideCaseBody) => Promise<DecideCaseResult>;
+    /** Sets or clears (`assigneeId: null`) the assignee (`cases:assign`). */
+    assign: (id: string, body: AssignCaseBody) => Promise<CaseView>;
+    /** Assigns the case to the caller (`cases:claim`). */
+    claim: (id: string) => Promise<CaseView>;
+    /**
+     * Closes the case (`cases:decide`). An undecided case gets a `reject` decision with reason
+     * code `case_closed` so its workflow run does not wait forever.
+     */
+    close: (id: string, body?: CloseCaseBody) => Promise<CaseView>;
+    /** Analyst notes on a case (`cases:notes`); edits and deletes are limited to the author or an admin. */
+    notes: {
+        list: (id: string) => Promise<CaseNote[]>;
+        create: (id: string, body: CaseNoteBody) => Promise<CaseNote>;
+        update: (id: string, noteId: string, body: CaseNoteBody) => Promise<CaseNote>;
+        remove: (id: string, noteId: string) => Promise<void>;
+    };
+};
+type CasesClient = ReturnType<typeof casesDomain>;
+/** Saved case filters (`cases:read` to list, `cases:assign` to manage). */
+declare function caseQueuesDomain(http: Http): {
+    list: () => Promise<CaseQueue[]>;
+    counts: () => Promise<CaseQueueCount[]>;
+    create: (body: UpsertCaseQueueBody) => Promise<CaseQueue>;
+    update: (id: string, body: UpsertCaseQueueBody) => Promise<CaseQueue>;
+    remove: (id: string) => Promise<void>;
+};
+type CaseQueuesClient = ReturnType<typeof caseQueuesDomain>;
+/** The reviewer directory (`cases:assign` or `cases:claim`); empty when none is configured. */
+declare function usersDomain(http: Http): {
+    list: (query?: UserListQuery) => Promise<DirectoryUser[]>;
+};
+type UsersClient = ReturnType<typeof usersDomain>;
+
+/**
+ * Applicants (submission-token clients) must name their submission on every `/documents/:id`
+ * route; operators and integrations omit it.
+ */
+interface DocumentScope {
+    submissionId?: string;
+}
+/** Filters of `GET /documents` (`documents:read`). */
+interface DocumentListQuery {
+    subjectId?: string;
+    submissionId?: string;
+    caseId?: string;
+    status?: DocumentStatus;
+    limit?: number;
+    offset?: number;
+}
+declare const DocumentList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        createdAt: z.ZodCoercedDate<unknown>;
+        updatedAt: z.ZodCoercedDate<unknown>;
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        subjectId: z.ZodGUID;
+        submissionId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        caseId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        fieldKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fileName: z.ZodString;
+        contentType: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        sha256: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        storageKey: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            uploaded: "uploaded";
+            scanning: "scanning";
+            clean: "clean";
+            infected: "infected";
+            rejected: "rejected";
+        }>;
+        scan: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            engine: z.ZodString;
+            signature: z.ZodOptional<z.ZodString>;
+            scannedAt: z.ZodCoercedDate<unknown>;
+        }, z.core.$strip>>>;
+        rejectionReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uploadedBy: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type DocumentList = z.infer<typeof DocumentList>;
+declare function documentsDomain(http: Http): {
+    /**
+     * Registers a pending document and returns the presigned POST to send the bytes with
+     * (`uploadToStorage`). Applicants pass their `submissionId` and the `fieldKey`.
+     */
+    create: (input: CreateDocumentInput) => Promise<DocumentUploadTicket>;
+    /**
+     * Verifies the uploaded object and starts the scan. Resolves with status `uploaded` or
+     * `rejected` (see `rejectionReason`); throws a 409 `ApiError` when nothing was uploaded.
+     */
+    finalize: (id: string, opts?: DocumentScope) => Promise<Document>;
+    get: (id: string, opts?: DocumentScope) => Promise<Document>;
+    list: (filters?: DocumentListQuery) => Promise<DocumentList>;
+    /** A 60-second presigned GET on the storage origin; open it directly, never via the API. */
+    download: (id: string, opts?: DocumentScope) => Promise<DocumentDownload>;
+};
+type DocumentsClient = ReturnType<typeof documentsDomain>;
+/** Thrown by `uploadToStorage`; `status` is 0 for network errors, aborts and timeouts. */
+declare class UploadError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+interface UploadProgressEvent {
+    lengthComputable: boolean;
+    loaded: number;
+    total: number;
+}
+/** The slice of `XMLHttpRequest` the uploader uses; injectable so tests need no network. */
+interface UploadXhr {
+    readonly status: number;
+    open(method: string, url: string): void;
+    send(body: FormData): void;
+    abort(): void;
+    addEventListener(type: 'load' | 'error' | 'abort' | 'timeout', listener: () => void): void;
+    upload: {
+        addEventListener(type: 'progress', listener: (event: UploadProgressEvent) => void): void;
+    };
+}
+interface UploadOptions {
+    /** Called with 0..1 as bytes leave the browser; called with 1 once storage accepts the file. */
+    onProgress?: (fraction: number) => void;
+    signal?: AbortSignal;
+    /** XMLHttpRequest factory; defaults to the global one. */
+    xhr?: () => UploadXhr;
+}
+/**
+ * Posts `file` to the presigned URL of `ticket` as multipart form data: the policy fields first,
+ * in order, then the file under `file`. The browser sets the multipart content type itself.
+ */
+declare function uploadToStorage(ticket: DocumentUploadTicket, file: Blob, opts?: UploadOptions): Promise<void>;
+type FileCheck = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Client-side pre-check mirroring the policy storage enforces; saves a doomed round trip. */
+declare function checkFileBeforeUpload(file: {
+    type: string;
+    size: number;
+    name: string;
+}): FileCheck;
+interface PollOptions extends DocumentScope {
+    intervalMs?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+/** Thrown by `pollDocument` when the scan does not settle within `timeoutMs`. */
+declare class DocumentPollTimeoutError extends Error {
+    readonly documentId: string;
+    constructor(documentId: string);
+}
+declare function isTerminalDocumentStatus(status: DocumentStatus): boolean;
+/**
+ * Reads the document until its status is terminal (`clean`, `infected` or `rejected`). The first
+ * read is immediate; later ones every `intervalMs` (750 ms) until `timeoutMs` (60 s).
+ */
+declare function pollDocument(client: {
+    documents: Pick<DocumentsClient, 'get'>;
+}, id: string, opts?: PollOptions): Promise<Document>;
+
+type StartWorkflowRunBody = z.input<typeof StartWorkflowRunInput>;
+/** Workflow runs: start, read, list by subject and the admin-only event history. */
+interface WorkflowRunsClient {
+    start: (body: StartWorkflowRunBody) => Promise<WorkflowRun>;
+    get: (id: string) => Promise<WorkflowRun>;
+    listBySubject: (subjectId: string) => Promise<WorkflowRun[]>;
+    /**
+     * The run's Temporal event history as proto JSON, for replaying it against a new worker
+     * bundle (`node dist/replay.js`). Admin only; 409 when the API has no Temporal client.
+     */
+    history: (id: string) => Promise<unknown>;
+}
+
+interface ApiClientOptions {
+    /** API origin, e.g. `http://localhost:4000`. A trailing slash is tolerated. */
+    baseUrl: string;
+    /**
+     * Returns the bearer token for the current caller (a Zitadel access token, or an applicant
+     * submission token). When it yields nothing the request is sent without `Authorization`.
+     */
+    getAccessToken: AccessTokenProvider;
+    /** Injectable for tests; defaults to the global fetch. */
+    fetch?: FetchLike;
+}
+type CreateSubjectBody = z.input<typeof CreateSubjectInput>;
+
+type ConfigurePluginBody = z.input<typeof ConfigurePluginInput>;
+type UpsertWorkflowDefinitionBody = z.input<typeof UpsertWorkflowDefinitionInput>;
+type UpsertRuleDefinitionBody = z.input<typeof UpsertRuleDefinitionInput>;
+/** Body of `PUT /rule-sets/:key`; `enabled`/`shadow` on each rule and `useCase` may be omitted. */
+type UpsertRuleSetBody = z.input<typeof UpsertRuleSetInput>;
+type UpsertCollectionFlowBody = z.input<typeof UpsertCollectionFlowInput>;
+type CreateSubmissionBody = z.input<typeof CreateSubmissionInput>;
+type SaveSubmissionBody = z.input<typeof SaveSubmissionInput>;
+type UpsertListBody = z.input<typeof UpsertListInput>;
+type AddListEntriesBody = z.input<typeof AddListEntriesInput>;
+type RemoveListEntriesBody = z.input<typeof RemoveListEntriesInput>;
+/** Body of `POST /events`: up to 1 000 events; `occurredAt` may be a Date or ISO string. */
+type IngestEventsBody = z.input<typeof IngestEventsInput>;
+/**
+ * Body of `POST /backtests`. `version` defaults to the latest version of the rule (drafts
+ * included); `sample` defaults to the last 30 days, 1 000 subjects.
+ */
+type StartBacktestBody = z.input<typeof StartBacktestInput>;
+/** Input of a dry run: a stored subject's id, or an inline data object (exactly one of the two). */
+type DryRunInput = {
+    subjectId: string;
+    data?: undefined;
+} | {
+    data: Record<string, unknown>;
+    subjectId?: undefined;
+};
+/** Body of `POST /rule-definitions/:key/dry-run`. `version` defaults to the latest draft. */
+type DryRunBody = DryRunInput & {
+    version?: number;
+};
+declare const HealthStatus: z.ZodObject<{
+    status: z.ZodLiteral<"ok">;
+}, z.core.$strip>;
+type HealthStatus = z.infer<typeof HealthStatus>;
+/** Who the API resolved the bearer token to (`GET /me`). */
+declare const MePrincipal: z.ZodObject<{
+    kind: z.ZodEnum<{
+        applicant: "applicant";
+        human: "human";
+        machine: "machine";
+    }>;
+    subject: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MePrincipal = z.infer<typeof MePrincipal>;
+declare const Me: z.ZodObject<{
+    principal: z.ZodObject<{
+        kind: z.ZodEnum<{
+            applicant: "applicant";
+            human: "human";
+            machine: "machine";
+        }>;
+        subject: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    tenantId: z.ZodString;
+    orgId: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type Me = z.infer<typeof Me>;
+declare const ReadyStatus: z.ZodObject<{
+    status: z.ZodEnum<{
+        ok: "ok";
+        degraded: "degraded";
+    }>;
+    checks: z.ZodObject<{
+        db: z.ZodEnum<{
+            error: "error";
+            ok: "ok";
+        }>;
+        temporal: z.ZodEnum<{
+            error: "error";
+            ok: "ok";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type ReadyStatus = z.infer<typeof ReadyStatus>;
+/** A plugin compiled into the deployment (`GET /plugins/available`). */
+declare const PluginSummary: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodArray<z.ZodString>;
+    secrets: z.ZodArray<z.ZodString>;
+    actions: z.ZodArray<z.ZodString>;
+    configSchema: z.ZodUnknown;
+}, z.core.$strip>;
+type PluginSummary = z.infer<typeof PluginSummary>;
+/** Rendering hints for the builder's schema-driven config forms; every part is optional. */
+declare const RuleUiHints: z.ZodObject<{
+    fieldOrder: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    help: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    listPicker: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type RuleUiHints = z.infer<typeof RuleUiHints>;
+declare const RuleTypeDescription: z.ZodObject<{
+    type: z.ZodEnum<{
+        plugin: "plugin";
+        comparison: "comparison";
+        list_lookup: "list_lookup";
+        score_threshold: "score_threshold";
+        expression: "expression";
+        velocity: "velocity";
+    }>;
+    description: z.ZodString;
+    configSchema: z.ZodUnknown;
+    dataPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    uiHints: z.ZodOptional<z.ZodObject<{
+        fieldOrder: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        help: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        listPicker: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type RuleTypeDescription = z.infer<typeof RuleTypeDescription>;
+/** Response of `POST /rule-definitions/:key/dry-run`: the evaluation plus what was evaluated. */
+declare const DryRunResult: z.ZodObject<{
+    result: z.ZodObject<{
+        ruleId: z.ZodString;
+        ruleKey: z.ZodString;
+        ruleVersion: z.ZodNumber;
+        severity: z.ZodEnum<{
+            info: "info";
+            warn: "warn";
+            block: "block";
+        }>;
+        weight: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        outcome: z.ZodEnum<{
+            error: "error";
+            pass: "pass";
+            fail: "fail";
+            skipped: "skipped";
+        }>;
+        score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        reasons: z.ZodArray<z.ZodString>;
+        details: z.ZodOptional<z.ZodUnknown>;
+        durationMs: z.ZodNumber;
+        shadow: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    rule: z.ZodObject<{
+        key: z.ZodString;
+        version: z.ZodNumber;
+        status: z.ZodEnum<{
+            draft: "draft";
+            pending_approval: "pending_approval";
+            published: "published";
+            archived: "archived";
+        }>;
+        type: z.ZodEnum<{
+            plugin: "plugin";
+            comparison: "comparison";
+            list_lookup: "list_lookup";
+            score_threshold: "score_threshold";
+            expression: "expression";
+            velocity: "velocity";
+        }>;
+    }, z.core.$strip>;
+    dataPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type DryRunResult = z.infer<typeof DryRunResult>;
+/** Response of `DELETE /lists/:key/entries`. */
+declare const RemovedCount: z.ZodObject<{
+    removed: z.ZodNumber;
+}, z.core.$strip>;
+type RemovedCount = z.infer<typeof RemovedCount>;
+declare const SubmissionDetail: z.ZodObject<{
+    submission: z.ZodObject<{
+        createdAt: z.ZodCoercedDate<unknown>;
+        updatedAt: z.ZodCoercedDate<unknown>;
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        flowDefinitionId: z.ZodGUID;
+        flowKey: z.ZodString;
+        flowVersion: z.ZodNumber;
+        subjectId: z.ZodGUID;
+        workflowRunId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            submitted: "submitted";
+        }>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        currentStepId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        submittedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    }, z.core.$strip>;
+    flow: z.ZodObject<{
+        createdAt: z.ZodCoercedDate<unknown>;
+        updatedAt: z.ZodCoercedDate<unknown>;
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        key: z.ZodString;
+        version: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        status: z.ZodEnum<{
+            draft: "draft";
+            pending_approval: "pending_approval";
+            published: "published";
+            archived: "archived";
+        }>;
+        definition: z.ZodObject<{
+            entryStepId: z.ZodString;
+            steps: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                fields: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    label: z.ZodString;
+                    type: z.ZodEnum<{
+                        number: "number";
+                        boolean: "boolean";
+                        date: "date";
+                        file: "file";
+                        email: "email";
+                        text: "text";
+                        select: "select";
+                    }>;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    placeholder: z.ZodOptional<z.ZodString>;
+                    help: z.ZodOptional<z.ZodString>;
+                    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodString;
+                        label: z.ZodString;
+                    }, z.core.$strip>>>;
+                    validation: z.ZodOptional<z.ZodObject<{
+                        min: z.ZodOptional<z.ZodNumber>;
+                        max: z.ZodOptional<z.ZodNumber>;
+                        pattern: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    visibleWhen: z.ZodOptional<z.ZodObject<{
+                        path: z.ZodString;
+                        op: z.ZodEnum<{
+                            in: "in";
+                            eq: "eq";
+                            neq: "neq";
+                            gt: "gt";
+                            gte: "gte";
+                            lt: "lt";
+                            lte: "lte";
+                            exists: "exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                next: z.ZodOptional<z.ZodString>;
+                branches: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    when: z.ZodObject<{
+                        path: z.ZodString;
+                        op: z.ZodEnum<{
+                            in: "in";
+                            eq: "eq";
+                            neq: "neq";
+                            gt: "gt";
+                            gte: "gte";
+                            lt: "lt";
+                            lte: "lte";
+                            exists: "exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>;
+                    next: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            linkTtlSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type SubmissionDetail = z.infer<typeof SubmissionDetail>;
+/**
+ * Response of `GET /collection-submissions/:id/status`: the applicant-readable view of a
+ * submission and of where its workflow run is. The collection flow polls it after submit.
+ */
+declare const SubmissionStatus: z.ZodObject<{
+    submission: z.ZodObject<{
+        id: z.ZodGUID;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            submitted: "submitted";
+        }>;
+        submittedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    }, z.core.$strip>;
+    run: z.ZodNullable<z.ZodObject<{
+        id: z.ZodGUID;
+        status: z.ZodEnum<{
+            running: "running";
+            waiting_collection: "waiting_collection";
+            waiting_manual: "waiting_manual";
+            waiting_callback: "waiting_callback";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>;
+        currentStepId: z.ZodNullable<z.ZodString>;
+        decision: z.ZodNullable<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+                manual_review: "manual_review";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type SubmissionStatus = z.infer<typeof SubmissionStatus>;
+/**
+ * Response of `POST /collection-submissions`. `link` is the collection-flow URL carrying the
+ * applicant token (hand it to the applicant or the embed loader; never log it); it is `null` when
+ * the API cannot mint applicant tokens.
+ */
+declare const CreatedSubmission: z.ZodObject<{
+    submission: z.ZodObject<{
+        createdAt: z.ZodCoercedDate<unknown>;
+        updatedAt: z.ZodCoercedDate<unknown>;
+        id: z.ZodGUID;
+        tenantId: z.ZodGUID;
+        flowDefinitionId: z.ZodGUID;
+        flowKey: z.ZodString;
+        flowVersion: z.ZodNumber;
+        subjectId: z.ZodGUID;
+        workflowRunId: z.ZodOptional<z.ZodNullable<z.ZodGUID>>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            submitted: "submitted";
+        }>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        currentStepId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        submittedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    }, z.core.$strip>;
+    link: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type CreatedSubmission = z.infer<typeof CreatedSubmission>;
+/** Response of `GET /collection-submissions/:id/embed`: what the embedded flow may be framed by. */
+declare const SubmissionEmbed: z.ZodObject<{
+    embedOrigins: z.ZodArray<z.ZodString>;
+    flowName: z.ZodString;
+}, z.core.$strip>;
+type SubmissionEmbed = z.infer<typeof SubmissionEmbed>;
+type PageQuery = {
+    limit?: number;
+    offset?: number;
+};
+/** @deprecated Use `AuditListQuery`; kept so existing `auditEvents.list` callers compile. */
+type AuditEventQuery = AuditListQuery;
+type PluginInvocationQuery = {
+    workflowRunId?: string;
+    limit?: number;
+};
+type ListEntryQuery = PageQuery & {
+    /** Substring match on the entry value. */
+    search?: string;
+};
+/** Filters of `GET /events`; `from`/`to` bound `occurredAt` and are sent as ISO strings. */
+type EventListQuery = PageQuery & {
+    subjectId?: string;
+    type?: string;
+    from?: Date | string;
+    to?: Date | string;
+};
+/** Builds a typed client for the Aletheia API. Methods throw `ApiError` on non-2xx responses. */
+declare function createApiClient(options: ApiClientOptions): {
+    health: {
+        check: () => Promise<HealthStatus>;
+        ready: () => Promise<ReadyStatus>;
+    };
+    /** The caller's principal, tenant and permissions as the API sees the bearer token. */
+    me: () => Promise<Me>;
+    subjects: {
+        create: (body: CreateSubjectBody) => Promise<Subject>;
+        /**
+         * Subjects matching `query`: `search` matches the external id and `data.name` /
+         * `data.legalName`; `riskScoreMin`/`riskScoreMax` bound the risk score (`subjects:read`).
+         */
+        list: (query?: SubjectListQuery) => Promise<Subject[]>;
+        get: (id: string) => Promise<Subject>;
+        /**
+         * The subject's history, newest first (`subjects:read`). Entries of kinds the caller may
+         * not read are omitted by the API; page with `offset`.
+         */
+        timeline: (id: string, query?: TimelineQuery) => Promise<TimelineEntry[]>;
+    };
+    workflowRuns: WorkflowRunsClient;
+    /** Review cases: filtered lists, detail, decide, assign/claim/close and notes. See `cases.ts`. */
+    cases: {
+        list: (query?: CaseListQuery) => Promise<_aletheia_dev_core.CaseView[]>;
+        get: (id: string) => Promise<CaseDetail>;
+        decide: (id: string, body: DecideCaseBody) => Promise<DecideCaseResult>;
+        assign: (id: string, body: AssignCaseBody) => Promise<_aletheia_dev_core.CaseView>;
+        claim: (id: string) => Promise<_aletheia_dev_core.CaseView>;
+        close: (id: string, body?: CloseCaseBody) => Promise<_aletheia_dev_core.CaseView>;
+        notes: {
+            list: (id: string) => Promise<_aletheia_dev_core.CaseNote[]>;
+            create: (id: string, body: CaseNoteBody) => Promise<_aletheia_dev_core.CaseNote>;
+            update: (id: string, noteId: string, body: CaseNoteBody) => Promise<_aletheia_dev_core.CaseNote>;
+            remove: (id: string, noteId: string) => Promise<void>;
+        };
+    };
+    /** Saved case filters shown in the workbench rail, with live counts. */
+    caseQueues: {
+        list: () => Promise<_aletheia_dev_core.CaseQueue[]>;
+        counts: () => Promise<CaseQueueCount[]>;
+        create: (body: UpsertCaseQueueBody) => Promise<_aletheia_dev_core.CaseQueue>;
+        update: (id: string, body: UpsertCaseQueueBody) => Promise<_aletheia_dev_core.CaseQueue>;
+        remove: (id: string) => Promise<void>;
+    };
+    /** The reviewer directory, for assignment and resolving assignee names. */
+    users: {
+        list: (query?: UserListQuery) => Promise<_aletheia_dev_core.DirectoryUser[]>;
+    };
+    workflowDefinitions: {
+        /** Validates a draft body without saving; issues carry step ids. */
+        validate: (body: {
+            name: string;
+            definition: {
+                entryStepId: string;
+                steps: ({
+                    id: string;
+                    type: "evaluate_rules";
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    ruleKeys?: string[] | undefined;
+                    ruleSetKey?: string | undefined;
+                    outputKey?: string | undefined;
+                } | {
+                    id: string;
+                    type: "call_plugin";
+                    plugin: string;
+                    action: string;
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    input?: Record<string, unknown> | undefined;
+                    inputMapping?: Record<string, string> | undefined;
+                    retry?: {
+                        maximumAttempts?: number | undefined;
+                        initialIntervalSeconds?: number | undefined;
+                    } | undefined;
+                } | {
+                    id: string;
+                    type: "wait_for_collection";
+                    flowKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    timeoutSeconds?: number | undefined;
+                    outputKey?: string | undefined;
+                } | {
+                    id: string;
+                    type: "create_case";
+                    caseType: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    priority?: "low" | "medium" | "high" | "critical" | undefined;
+                    slaHours?: number | undefined;
+                    outputKey?: string | undefined;
+                } | {
+                    id: string;
+                    type: "emit_decision";
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    mode?: "fixed" | "from_rules" | undefined;
+                    rulesKey?: string | undefined;
+                    manualDecisionKey?: string | undefined;
+                    outcome?: "approve" | "reject" | "manual_review" | undefined;
+                } | {
+                    id: string;
+                    type: "branch";
+                    conditions: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[];
+                    default: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                })[];
+                ui?: {
+                    positions?: Record<string, {
+                        x: number;
+                        y: number;
+                    }> | undefined;
+                } | undefined;
+            };
+            description?: string | undefined;
+            trigger?: "manual" | "subject.created" | "event" | undefined;
+        }) => Promise<_aletheia_dev_core.ValidationReport>;
+        list: () => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            trigger: "manual" | "subject.created" | "event";
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                entryStepId: string;
+                steps: ({
+                    id: string;
+                    type: "evaluate_rules";
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    ruleKeys?: string[] | undefined;
+                    ruleSetKey?: string | undefined;
+                } | {
+                    id: string;
+                    type: "call_plugin";
+                    plugin: string;
+                    action: string;
+                    input: Record<string, unknown>;
+                    inputMapping: Record<string, string>;
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    retry?: {
+                        maximumAttempts?: number | undefined;
+                        initialIntervalSeconds?: number | undefined;
+                    } | undefined;
+                } | {
+                    id: string;
+                    type: "wait_for_collection";
+                    flowKey: string;
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    timeoutSeconds?: number | undefined;
+                } | {
+                    id: string;
+                    type: "create_case";
+                    caseType: string;
+                    priority: "low" | "medium" | "high" | "critical";
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    slaHours?: number | undefined;
+                } | {
+                    id: string;
+                    type: "emit_decision";
+                    mode: "fixed" | "from_rules";
+                    rulesKey: string;
+                    manualDecisionKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    outcome?: "approve" | "reject" | "manual_review" | undefined;
+                } | {
+                    id: string;
+                    type: "branch";
+                    conditions: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[];
+                    default: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                })[];
+                ui?: {
+                    positions: Record<string, {
+                        x: number;
+                        y: number;
+                    }>;
+                } | undefined;
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }[]>;
+        get: (key: string) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            trigger: "manual" | "subject.created" | "event";
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                entryStepId: string;
+                steps: ({
+                    id: string;
+                    type: "evaluate_rules";
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    ruleKeys?: string[] | undefined;
+                    ruleSetKey?: string | undefined;
+                } | {
+                    id: string;
+                    type: "call_plugin";
+                    plugin: string;
+                    action: string;
+                    input: Record<string, unknown>;
+                    inputMapping: Record<string, string>;
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    retry?: {
+                        maximumAttempts?: number | undefined;
+                        initialIntervalSeconds?: number | undefined;
+                    } | undefined;
+                } | {
+                    id: string;
+                    type: "wait_for_collection";
+                    flowKey: string;
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    timeoutSeconds?: number | undefined;
+                } | {
+                    id: string;
+                    type: "create_case";
+                    caseType: string;
+                    priority: "low" | "medium" | "high" | "critical";
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    slaHours?: number | undefined;
+                } | {
+                    id: string;
+                    type: "emit_decision";
+                    mode: "fixed" | "from_rules";
+                    rulesKey: string;
+                    manualDecisionKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    outcome?: "approve" | "reject" | "manual_review" | undefined;
+                } | {
+                    id: string;
+                    type: "branch";
+                    conditions: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[];
+                    default: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                })[];
+                ui?: {
+                    positions: Record<string, {
+                        x: number;
+                        y: number;
+                    }>;
+                } | undefined;
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }>;
+        upsert: (key: string, body: {
+            name: string;
+            definition: {
+                entryStepId: string;
+                steps: ({
+                    id: string;
+                    type: "evaluate_rules";
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    ruleKeys?: string[] | undefined;
+                    ruleSetKey?: string | undefined;
+                    outputKey?: string | undefined;
+                } | {
+                    id: string;
+                    type: "call_plugin";
+                    plugin: string;
+                    action: string;
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    input?: Record<string, unknown> | undefined;
+                    inputMapping?: Record<string, string> | undefined;
+                    retry?: {
+                        maximumAttempts?: number | undefined;
+                        initialIntervalSeconds?: number | undefined;
+                    } | undefined;
+                } | {
+                    id: string;
+                    type: "wait_for_collection";
+                    flowKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    timeoutSeconds?: number | undefined;
+                    outputKey?: string | undefined;
+                } | {
+                    id: string;
+                    type: "create_case";
+                    caseType: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    priority?: "low" | "medium" | "high" | "critical" | undefined;
+                    slaHours?: number | undefined;
+                    outputKey?: string | undefined;
+                } | {
+                    id: string;
+                    type: "emit_decision";
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    mode?: "fixed" | "from_rules" | undefined;
+                    rulesKey?: string | undefined;
+                    manualDecisionKey?: string | undefined;
+                    outcome?: "approve" | "reject" | "manual_review" | undefined;
+                } | {
+                    id: string;
+                    type: "branch";
+                    conditions: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[];
+                    default: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                })[];
+                ui?: {
+                    positions?: Record<string, {
+                        x: number;
+                        y: number;
+                    }> | undefined;
+                } | undefined;
+            };
+            description?: string | undefined;
+            trigger?: "manual" | "subject.created" | "event" | undefined;
+        }) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            trigger: "manual" | "subject.created" | "event";
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                entryStepId: string;
+                steps: ({
+                    id: string;
+                    type: "evaluate_rules";
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    ruleKeys?: string[] | undefined;
+                    ruleSetKey?: string | undefined;
+                } | {
+                    id: string;
+                    type: "call_plugin";
+                    plugin: string;
+                    action: string;
+                    input: Record<string, unknown>;
+                    inputMapping: Record<string, string>;
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    retry?: {
+                        maximumAttempts?: number | undefined;
+                        initialIntervalSeconds?: number | undefined;
+                    } | undefined;
+                } | {
+                    id: string;
+                    type: "wait_for_collection";
+                    flowKey: string;
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    timeoutSeconds?: number | undefined;
+                } | {
+                    id: string;
+                    type: "create_case";
+                    caseType: string;
+                    priority: "low" | "medium" | "high" | "critical";
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    slaHours?: number | undefined;
+                } | {
+                    id: string;
+                    type: "emit_decision";
+                    mode: "fixed" | "from_rules";
+                    rulesKey: string;
+                    manualDecisionKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    outcome?: "approve" | "reject" | "manual_review" | undefined;
+                } | {
+                    id: string;
+                    type: "branch";
+                    conditions: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[];
+                    default: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                })[];
+                ui?: {
+                    positions: Record<string, {
+                        x: number;
+                        y: number;
+                    }>;
+                } | undefined;
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }>;
+        publish: (key: string) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            trigger: "manual" | "subject.created" | "event";
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                entryStepId: string;
+                steps: ({
+                    id: string;
+                    type: "evaluate_rules";
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    ruleKeys?: string[] | undefined;
+                    ruleSetKey?: string | undefined;
+                } | {
+                    id: string;
+                    type: "call_plugin";
+                    plugin: string;
+                    action: string;
+                    input: Record<string, unknown>;
+                    inputMapping: Record<string, string>;
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    retry?: {
+                        maximumAttempts?: number | undefined;
+                        initialIntervalSeconds?: number | undefined;
+                    } | undefined;
+                } | {
+                    id: string;
+                    type: "wait_for_collection";
+                    flowKey: string;
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    timeoutSeconds?: number | undefined;
+                } | {
+                    id: string;
+                    type: "create_case";
+                    caseType: string;
+                    priority: "low" | "medium" | "high" | "critical";
+                    outputKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    slaHours?: number | undefined;
+                } | {
+                    id: string;
+                    type: "emit_decision";
+                    mode: "fixed" | "from_rules";
+                    rulesKey: string;
+                    manualDecisionKey: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                    outcome?: "approve" | "reject" | "manual_review" | undefined;
+                } | {
+                    id: string;
+                    type: "branch";
+                    conditions: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[];
+                    default: string;
+                    name?: string | undefined;
+                    next?: string | undefined;
+                })[];
+                ui?: {
+                    positions: Record<string, {
+                        x: number;
+                        y: number;
+                    }>;
+                } | undefined;
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }>;
+    };
+    /** Step and field type schemas behind the builder's forms. */
+    builder: BuilderClient;
+    ruleDefinitions: {
+        /** Evaluates one rule version against a subject or inline data; nothing is recorded. */
+        dryRun: (key: string, body: DryRunBody) => Promise<DryRunResult>;
+        list: () => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            type: "plugin" | "comparison" | "list_lookup" | "score_threshold" | "expression" | "velocity";
+            config: unknown;
+            severity: "info" | "warn" | "block";
+            enabled: boolean;
+            tags: string[];
+            status: "draft" | "pending_approval" | "published" | "archived";
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+            weight?: number | null | undefined;
+        }[]>;
+        get: (key: string) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            type: "plugin" | "comparison" | "list_lookup" | "score_threshold" | "expression" | "velocity";
+            config: unknown;
+            severity: "info" | "warn" | "block";
+            enabled: boolean;
+            tags: string[];
+            status: "draft" | "pending_approval" | "published" | "archived";
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+            weight?: number | null | undefined;
+        }>;
+        upsert: (key: string, body: {
+            name: string;
+            type: "plugin" | "comparison" | "list_lookup" | "score_threshold" | "expression" | "velocity";
+            config: unknown;
+            description?: string | undefined;
+            severity?: "info" | "warn" | "block" | undefined;
+            weight?: number | undefined;
+            enabled?: boolean | undefined;
+            tags?: string[] | undefined;
+        }) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            type: "plugin" | "comparison" | "list_lookup" | "score_threshold" | "expression" | "velocity";
+            config: unknown;
+            severity: "info" | "warn" | "block";
+            enabled: boolean;
+            tags: string[];
+            status: "draft" | "pending_approval" | "published" | "archived";
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+            weight?: number | null | undefined;
+        }>;
+        publish: (key: string) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            type: "plugin" | "comparison" | "list_lookup" | "score_threshold" | "expression" | "velocity";
+            config: unknown;
+            severity: "info" | "warn" | "block";
+            enabled: boolean;
+            tags: string[];
+            status: "draft" | "pending_approval" | "published" | "archived";
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+            weight?: number | null | undefined;
+        }>;
+    };
+    ruleTypes: {
+        list: () => Promise<RuleTypeDescription[]>;
+    };
+    /** Versioned, ordered groups of rules with an aggregation policy (`/rule-sets`). */
+    ruleSets: {
+        list: () => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            useCase: "custom" | "onboarding" | "underwriting" | "monitoring";
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                rules: {
+                    ruleKey: string;
+                    enabled: boolean;
+                    shadow: boolean;
+                    weightOverride?: number | undefined;
+                }[];
+                policy: {
+                    mode: "max_severity";
+                } | {
+                    mode: "sum_weights";
+                    clamp: {
+                        min: number;
+                        max: number;
+                    };
+                    bands: {
+                        min: number;
+                        max: number;
+                        outcome: "approve" | "reject" | "manual_review";
+                    }[];
+                } | {
+                    mode: "first_match";
+                    default: "approve" | "reject" | "manual_review";
+                };
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }[]>;
+        get: (key: string) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            useCase: "custom" | "onboarding" | "underwriting" | "monitoring";
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                rules: {
+                    ruleKey: string;
+                    enabled: boolean;
+                    shadow: boolean;
+                    weightOverride?: number | undefined;
+                }[];
+                policy: {
+                    mode: "max_severity";
+                } | {
+                    mode: "sum_weights";
+                    clamp: {
+                        min: number;
+                        max: number;
+                    };
+                    bands: {
+                        min: number;
+                        max: number;
+                        outcome: "approve" | "reject" | "manual_review";
+                    }[];
+                } | {
+                    mode: "first_match";
+                    default: "approve" | "reject" | "manual_review";
+                };
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }>;
+        upsert: (key: string, body: {
+            name: string;
+            definition: {
+                rules: {
+                    ruleKey: string;
+                    enabled?: boolean | undefined;
+                    weightOverride?: number | undefined;
+                    shadow?: boolean | undefined;
+                }[];
+                policy: {
+                    mode: "max_severity";
+                } | {
+                    mode: "sum_weights";
+                    bands: {
+                        min: number;
+                        max: number;
+                        outcome: "approve" | "reject" | "manual_review";
+                    }[];
+                    clamp?: {
+                        min?: number | undefined;
+                        max?: number | undefined;
+                    } | undefined;
+                } | {
+                    mode: "first_match";
+                    default?: "approve" | "reject" | "manual_review" | undefined;
+                };
+            };
+            description?: string | undefined;
+            useCase?: "custom" | "onboarding" | "underwriting" | "monitoring" | undefined;
+        }) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            useCase: "custom" | "onboarding" | "underwriting" | "monitoring";
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                rules: {
+                    ruleKey: string;
+                    enabled: boolean;
+                    shadow: boolean;
+                    weightOverride?: number | undefined;
+                }[];
+                policy: {
+                    mode: "max_severity";
+                } | {
+                    mode: "sum_weights";
+                    clamp: {
+                        min: number;
+                        max: number;
+                    };
+                    bands: {
+                        min: number;
+                        max: number;
+                        outcome: "approve" | "reject" | "manual_review";
+                    }[];
+                } | {
+                    mode: "first_match";
+                    default: "approve" | "reject" | "manual_review";
+                };
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }>;
+        publish: (key: string) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            useCase: "custom" | "onboarding" | "underwriting" | "monitoring";
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                rules: {
+                    ruleKey: string;
+                    enabled: boolean;
+                    shadow: boolean;
+                    weightOverride?: number | undefined;
+                }[];
+                policy: {
+                    mode: "max_severity";
+                } | {
+                    mode: "sum_weights";
+                    clamp: {
+                        min: number;
+                        max: number;
+                    };
+                    bands: {
+                        min: number;
+                        max: number;
+                        outcome: "approve" | "reject" | "manual_review";
+                    }[];
+                } | {
+                    mode: "first_match";
+                    default: "approve" | "reject" | "manual_review";
+                };
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }>;
+    };
+    collectionFlows: {
+        /** Validates a draft flow body without saving; issues carry step / field keys. */
+        validate: (body: {
+            name: string;
+            definition: {
+                entryStepId: string;
+                steps: {
+                    id: string;
+                    title: string;
+                    fields: {
+                        key: string;
+                        label: string;
+                        type: "number" | "boolean" | "date" | "file" | "email" | "text" | "select";
+                        required?: boolean | undefined;
+                        placeholder?: string | undefined;
+                        help?: string | undefined;
+                        options?: {
+                            value: string;
+                            label: string;
+                        }[] | undefined;
+                        validation?: {
+                            min?: number | undefined;
+                            max?: number | undefined;
+                            pattern?: string | undefined;
+                        } | undefined;
+                        visibleWhen?: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        } | undefined;
+                    }[];
+                    description?: string | undefined;
+                    next?: string | undefined;
+                    branches?: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[] | undefined;
+                }[];
+                linkTtlSeconds?: number | undefined;
+            };
+            description?: string | undefined;
+        }) => Promise<_aletheia_dev_core.ValidationReport>;
+        list: () => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                entryStepId: string;
+                steps: {
+                    id: string;
+                    title: string;
+                    fields: {
+                        key: string;
+                        label: string;
+                        type: "number" | "boolean" | "date" | "file" | "email" | "text" | "select";
+                        required: boolean;
+                        placeholder?: string | undefined;
+                        help?: string | undefined;
+                        options?: {
+                            value: string;
+                            label: string;
+                        }[] | undefined;
+                        validation?: {
+                            min?: number | undefined;
+                            max?: number | undefined;
+                            pattern?: string | undefined;
+                        } | undefined;
+                        visibleWhen?: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        } | undefined;
+                    }[];
+                    description?: string | undefined;
+                    next?: string | undefined;
+                    branches?: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[] | undefined;
+                }[];
+                linkTtlSeconds: number;
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }[]>;
+        get: (key: string) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                entryStepId: string;
+                steps: {
+                    id: string;
+                    title: string;
+                    fields: {
+                        key: string;
+                        label: string;
+                        type: "number" | "boolean" | "date" | "file" | "email" | "text" | "select";
+                        required: boolean;
+                        placeholder?: string | undefined;
+                        help?: string | undefined;
+                        options?: {
+                            value: string;
+                            label: string;
+                        }[] | undefined;
+                        validation?: {
+                            min?: number | undefined;
+                            max?: number | undefined;
+                            pattern?: string | undefined;
+                        } | undefined;
+                        visibleWhen?: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        } | undefined;
+                    }[];
+                    description?: string | undefined;
+                    next?: string | undefined;
+                    branches?: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[] | undefined;
+                }[];
+                linkTtlSeconds: number;
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }>;
+        upsert: (key: string, body: {
+            name: string;
+            definition: {
+                entryStepId: string;
+                steps: {
+                    id: string;
+                    title: string;
+                    fields: {
+                        key: string;
+                        label: string;
+                        type: "number" | "boolean" | "date" | "file" | "email" | "text" | "select";
+                        required?: boolean | undefined;
+                        placeholder?: string | undefined;
+                        help?: string | undefined;
+                        options?: {
+                            value: string;
+                            label: string;
+                        }[] | undefined;
+                        validation?: {
+                            min?: number | undefined;
+                            max?: number | undefined;
+                            pattern?: string | undefined;
+                        } | undefined;
+                        visibleWhen?: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        } | undefined;
+                    }[];
+                    description?: string | undefined;
+                    next?: string | undefined;
+                    branches?: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[] | undefined;
+                }[];
+                linkTtlSeconds?: number | undefined;
+            };
+            description?: string | undefined;
+        }) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                entryStepId: string;
+                steps: {
+                    id: string;
+                    title: string;
+                    fields: {
+                        key: string;
+                        label: string;
+                        type: "number" | "boolean" | "date" | "file" | "email" | "text" | "select";
+                        required: boolean;
+                        placeholder?: string | undefined;
+                        help?: string | undefined;
+                        options?: {
+                            value: string;
+                            label: string;
+                        }[] | undefined;
+                        validation?: {
+                            min?: number | undefined;
+                            max?: number | undefined;
+                            pattern?: string | undefined;
+                        } | undefined;
+                        visibleWhen?: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        } | undefined;
+                    }[];
+                    description?: string | undefined;
+                    next?: string | undefined;
+                    branches?: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[] | undefined;
+                }[];
+                linkTtlSeconds: number;
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }>;
+        publish: (key: string) => Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            tenantId: string;
+            key: string;
+            version: number;
+            name: string;
+            status: "draft" | "pending_approval" | "published" | "archived";
+            definition: {
+                entryStepId: string;
+                steps: {
+                    id: string;
+                    title: string;
+                    fields: {
+                        key: string;
+                        label: string;
+                        type: "number" | "boolean" | "date" | "file" | "email" | "text" | "select";
+                        required: boolean;
+                        placeholder?: string | undefined;
+                        help?: string | undefined;
+                        options?: {
+                            value: string;
+                            label: string;
+                        }[] | undefined;
+                        validation?: {
+                            min?: number | undefined;
+                            max?: number | undefined;
+                            pattern?: string | undefined;
+                        } | undefined;
+                        visibleWhen?: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        } | undefined;
+                    }[];
+                    description?: string | undefined;
+                    next?: string | undefined;
+                    branches?: {
+                        when: {
+                            path: string;
+                            op: "in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "exists";
+                            value?: unknown;
+                        };
+                        next: string;
+                    }[] | undefined;
+                }[];
+                linkTtlSeconds: number;
+            };
+            createdBy?: string | null | undefined;
+            description?: string | null | undefined;
+        }>;
+    };
+    collectionSubmissions: {
+        /** Creates the submission and returns the applicant link alongside it. */
+        create: (body: CreateSubmissionBody) => Promise<CreatedSubmission>;
+        get: (id: string) => Promise<SubmissionDetail>;
+        save: (id: string, body: SaveSubmissionBody) => Promise<CollectionSubmission>;
+        submit: (id: string) => Promise<CollectionSubmission>;
+        /** Where the submission's workflow run is; readable with the applicant's token. */
+        status: (id: string) => Promise<SubmissionStatus>;
+        /** Embed allow-list and flow name for the submission; readable with the applicant's token. */
+        embed: (id: string) => Promise<SubmissionEmbed>;
+    };
+    /** Subject events: the facts velocity rules aggregate over. */
+    events: {
+        /** Inserts events; re-sent idempotency keys are counted as `duplicates`, not errors. */
+        ingest: (body: IngestEventsBody) => Promise<IngestEventsResult>;
+        /** Newest first. */
+        list: (query?: EventListQuery) => Promise<Event[]>;
+    };
+    /**
+     * Replays recorded evaluations against a rule version (`backtests:run`). `start` returns the
+     * queued job; poll `get` until its status is `completed` (with `summary`) or `failed`.
+     */
+    backtests: {
+        start: (body: StartBacktestBody) => Promise<Backtest>;
+        /** Newest first. */
+        list: (query?: PageQuery) => Promise<Backtest[]>;
+        get: (id: string) => Promise<Backtest>;
+    };
+    decisions: {
+        listBySubject: (subjectId: string) => Promise<Decision[]>;
+    };
+    /** Filtered audit trail, exports and manifest verification (`audit:read`). See `audit.ts`. */
+    audit: AuditClient;
+    /** @deprecated Alias of `audit`, kept for existing callers. */
+    auditEvents: {
+        list: (query?: AuditEventQuery) => Promise<AuditEvent[]>;
+    };
+    /** Version history, diffs and the approval workflow of definitions. See `governance.ts`. */
+    governance: GovernanceClient;
+    plugins: {
+        list: () => Promise<PluginDefinition[]>;
+        available: () => Promise<PluginSummary[]>;
+        configure: (name: string, body: ConfigurePluginBody) => Promise<PluginDefinition>;
+    };
+    pluginInvocations: {
+        list: (query?: PluginInvocationQuery) => Promise<PluginInvocation[]>;
+    };
+    /**
+     * Uploaded files: `create` -> `uploadToStorage` (helper) -> `finalize` -> `pollDocument`
+     * (helper) until the scan settles. See `documents.ts`.
+     */
+    documents: {
+        create: (input: _aletheia_dev_core.CreateDocumentInput) => Promise<_aletheia_dev_core.DocumentUploadTicket>;
+        finalize: (id: string, opts?: DocumentScope) => Promise<_aletheia_dev_core.Document>;
+        get: (id: string, opts?: DocumentScope) => Promise<_aletheia_dev_core.Document>;
+        list: (filters?: DocumentListQuery) => Promise<DocumentList>;
+        download: (id: string, opts?: DocumentScope) => Promise<_aletheia_dev_core.DocumentDownload>;
+    };
+    /** Tenant settings such as the embed origin allow-list (`tenants:settings`). */
+    tenants: TenantsClient;
+    /** Tenant lists (blocklists / allowlists) and their entries. Lists are keyed, not versioned. */
+    lists: {
+        list: () => Promise<List[]>;
+        get: (key: string) => Promise<List>;
+        /** Creates the list or updates its metadata; entries are untouched. */
+        upsert: (key: string, body: UpsertListBody) => Promise<List>;
+        remove: (key: string) => Promise<void>;
+        entries: (key: string, query?: ListEntryQuery) => Promise<ListEntry[]>;
+        addEntries: (key: string, body: AddListEntriesBody) => Promise<ListImportResult>;
+        removeEntries: (key: string, body: RemoveListEntriesBody) => Promise<RemovedCount>;
+        /** Uploads a CSV (one value per line, optional `value,reason,expires_at` header). */
+        importCsv: (key: string, csv: string) => Promise<ListImportResult>;
+    };
+};
+type ApiClient = ReturnType<typeof createApiClient>;
+
+/**
+ * Runtime configuration for the UIs, served as `GET /config.json` from the same origin as the
+ * app. The `web` image's entrypoint writes one file per app from environment variables, so one
+ * image serves every environment. The dev servers serve `public/config.json`, an empty object,
+ * so the `VITE_*` values from the root `.env` and the localhost defaults apply instead.
+ *
+ * Every key is optional and an empty string counts as absent, so a partially rendered file
+ * falls through to the next source. `zitadelClientId` differs per app.
+ */
+declare const RuntimeConfig: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    zitadelIssuer: z.ZodOptional<z.ZodString>;
+    zitadelProjectId: z.ZodOptional<z.ZodString>;
+    zitadelClientId: z.ZodOptional<z.ZodString>;
+    zitadelOrgDomain: z.ZodOptional<z.ZodString>;
+    collectionFlowUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RuntimeConfig = z.infer<typeof RuntimeConfig>;
+type RuntimeConfigKey = keyof RuntimeConfig;
+/** Every key resolved to a string (possibly empty when no source provides it). */
+type ResolvedConfig = Record<RuntimeConfigKey, string>;
+declare const RUNTIME_CONFIG_PATH = "/config.json";
+/**
+ * Fetches `/config.json` without caching so a redeploy with new values takes effect on the next
+ * load. A missing file, a non-JSON body, a body that fails the schema or a network error all
+ * yield `{}`: the caller's fallbacks then apply.
+ */
+declare function loadRuntimeConfig(fetchImpl?: FetchLike): Promise<RuntimeConfig>;
+/**
+ * Merges the three sources: the runtime file wins, then the build-time `VITE_*` values the app
+ * maps onto the same keys, then the app's defaults. Empty strings never win over a later source.
+ */
+declare function resolveConfig(runtime: RuntimeConfig, env: Partial<Record<RuntimeConfigKey, string | undefined>>, defaults: ResolvedConfig): ResolvedConfig;
+
+export { type AccessTokenProvider, type AddListEntriesBody, type ApiClient, type ApiClientOptions, ApiError, type ApiErrorBody, type ApprovalListQuery, ApprovalOutcome, type AssignCaseBody, type AuditClient, type AuditEventQuery, type AuditFilterQuery, type AuditListQuery, type BuilderClient, CaseDetail, type CaseListQuery, type CaseNoteBody, CaseQueueCount, type CaseQueuesClient, type CasesClient, type CloseCaseBody, type CreateSubjectBody, type CreateSubmissionBody, CreatedSubmission, type DecideCaseBody, DecideCaseResult, type DiffQuery, DocumentList, type DocumentListQuery, DocumentPollTimeoutError, type DocumentScope, type DocumentsClient, type DryRunBody, type DryRunInput, DryRunResult, type EventListQuery, type ExportVerification, FORBIDDEN_CODES, type FetchLike, type FileCheck, type GovernanceClient, HealthStatus, type IngestEventsBody, type ListEntryQuery, Me, MePrincipal, type PageQuery, type PluginInvocationQuery, PluginSummary, type PollOptions, RUNTIME_CONFIG_PATH, type RawBody, ReadyStatus, type RemoveListEntriesBody, RemovedCount, type ResolvedConfig, RuleTypeDescription, RuleUiHints, RuntimeConfig, type RuntimeConfigKey, type SaveSubmissionBody, type StartBacktestBody, type StartWorkflowRunBody, SubmissionDetail, SubmissionEmbed, SubmissionStatus, type TenantsClient, UploadError, type UploadOptions, type UploadProgressEvent, type UploadXhr, type UpsertCaseQueueBody, type UpsertCollectionFlowBody, type UpsertListBody, type UpsertRuleDefinitionBody, type UpsertRuleSetBody, type UpsertWorkflowDefinitionBody, type UserListQuery, type UsersClient, type ValidateCollectionFlowBody, type ValidateWorkflowBody, auditFilterParams, caseListParams, checkFileBeforeUpload, createApiClient, isApiError, isApiErrorBody, isForbidden, isTenantNotProvisioned, isTerminalDocumentStatus, isUnauthenticated, loadRuntimeConfig, pollDocument, resolveConfig, uploadToStorage, verifyExport };