@aletheia-dev/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1442 @@
+// src/base.ts
+import { z } from "zod";
+var Id = z.guid();
+var JsonObject = z.record(z.string(), z.unknown());
+var Timestamps = z.object({
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date()
+});
+var BaseEntity = z.object({ id: Id, tenantId: Id, ...Timestamps.shape });
+var DefinitionStatus = z.enum(["draft", "pending_approval", "published", "archived"]);
+var DefinitionKey = z.string().min(1).max(100).regex(/^[a-z0-9][a-z0-9_-]*$/, 'keys are lowercase letters, digits, "_" or "-"');
+
+// src/tenant.ts
+import { z as z2 } from "zod";
+var ActorType = z2.enum(["user", "service", "applicant", "system", "plugin", "workflow"]);
+var Actor = z2.object({ type: ActorType, id: z2.string().min(1) });
+var TenantContext = z2.object({ tenantId: Id, actor: Actor });
+var SYSTEM_ACTOR = { type: "system", id: "system" };
+var DEV_TENANT_ID = "00000000-0000-0000-0000-000000000001";
+var WebOrigin = z2.string().regex(/^https?:\/\/[a-z0-9.-]+(:\d{1,5})?$/i, "must be an origin like https://merchant.example");
+var CaseSettings = z2.object({
+  /** SLA applied to cases whose `create_case` step sets no `slaHours`. */
+  defaultSlaHours: z2.number().positive().max(24 * 90).optional()
+});
+var ApprovalSettings = z2.object({
+  /** When true, drafts are published only through an approval. */
+  required: z2.boolean().default(false),
+  /** When approvals are required, the requester may not approve their own change. */
+  fourEyes: z2.boolean().default(true)
+});
+var TenantSettings = z2.object({
+  /** Merchant origins allowed to embed this tenant's collection flows in an iframe. */
+  embedOrigins: z2.array(WebOrigin).max(20).default([]),
+  cases: CaseSettings.default({}),
+  approvals: ApprovalSettings.default({ required: false, fourEyes: true })
+});
+var Tenant = z2.object({
+  id: Id,
+  name: z2.string().min(1),
+  settings: TenantSettings.default({
+    embedOrigins: [],
+    cases: {},
+    approvals: { required: false, fourEyes: true }
+  }),
+  createdAt: z2.coerce.date()
+});
+function systemContext(tenantId) {
+  return { tenantId, actor: SYSTEM_ACTOR };
+}
+var DirectoryUser = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  email: z2.string().optional(),
+  /** Project roles the user holds, e.g. `analyst`. */
+  roles: z2.array(z2.string())
+});
+
+// src/condition.ts
+import { z as z3 } from "zod";
+var ConditionOp = z3.enum(["eq", "neq", "gt", "gte", "lt", "lte", "in", "exists"]);
+var Condition = z3.object({
+  path: z3.string().min(1),
+  op: ConditionOp,
+  value: z3.unknown().optional()
+});
+function getPath(source, path) {
+  let current = source;
+  for (const segment of path.split(".")) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function compareNumbers(actual, expected, op) {
+  const a = typeof actual === "number" ? actual : Number(actual);
+  const b = typeof expected === "number" ? expected : Number(expected);
+  if (Number.isNaN(a) || Number.isNaN(b)) return false;
+  switch (op) {
+    case "gt":
+      return a > b;
+    case "gte":
+      return a >= b;
+    case "lt":
+      return a < b;
+    case "lte":
+      return a <= b;
+    default:
+      return false;
+  }
+}
+function evaluateCondition(condition, data) {
+  const actual = getPath(data, condition.path);
+  switch (condition.op) {
+    case "exists":
+      return actual !== void 0 && actual !== null;
+    case "eq":
+      return actual === condition.value;
+    case "neq":
+      return actual !== condition.value;
+    case "in":
+      return Array.isArray(condition.value) && condition.value.includes(actual);
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+      return compareNumbers(actual, condition.value, condition.op);
+  }
+}
+
+// src/subject.ts
+import { z as z4 } from "zod";
+var SubjectKind = z4.enum(["merchant", "seller", "user"]);
+var SubjectStatus = z4.enum(["active", "blocked", "closed"]);
+var Subject = BaseEntity.extend({
+  kind: SubjectKind,
+  externalId: z4.string().nullish(),
+  status: SubjectStatus,
+  data: JsonObject,
+  riskScore: z4.number().nullish(),
+  tags: z4.array(z4.string())
+});
+var CreateSubjectInput = z4.object({
+  kind: SubjectKind,
+  externalId: z4.string().min(1).optional(),
+  data: JsonObject.default({}),
+  tags: z4.array(z4.string()).default([])
+});
+var SubjectListQuery = z4.object({
+  search: z4.string().min(1).max(200).optional(),
+  kind: SubjectKind.optional(),
+  status: SubjectStatus.optional(),
+  riskScoreMin: z4.coerce.number().min(0).max(100).optional(),
+  riskScoreMax: z4.coerce.number().min(0).max(100).optional(),
+  limit: z4.coerce.number().int().positive().optional(),
+  offset: z4.coerce.number().int().nonnegative().optional()
+});
+
+// src/rule.ts
+import { z as z5 } from "zod";
+var RuleType = z5.enum([
+  "comparison",
+  "list_lookup",
+  "score_threshold",
+  "expression",
+  "plugin",
+  "velocity"
+]);
+var RuleSeverity = z5.enum(["info", "warn", "block"]);
+var RuleDefinition = BaseEntity.extend({
+  /** Actor id that created this version; null for rows older than PR 19. */
+  createdBy: z5.string().nullish(),
+  key: DefinitionKey,
+  version: z5.number().int().positive(),
+  name: z5.string().min(1),
+  description: z5.string().nullish(),
+  type: RuleType,
+  config: z5.unknown(),
+  severity: RuleSeverity,
+  weight: z5.number().nullish(),
+  enabled: z5.boolean(),
+  tags: z5.array(z5.string()),
+  status: DefinitionStatus
+});
+var UpsertRuleDefinitionInput = z5.object({
+  name: z5.string().min(1),
+  description: z5.string().optional(),
+  type: RuleType,
+  config: z5.unknown(),
+  severity: RuleSeverity.default("block"),
+  weight: z5.number().optional(),
+  enabled: z5.boolean().default(true),
+  tags: z5.array(z5.string()).default([])
+});
+var RuleOutcome = z5.enum(["pass", "fail", "error", "skipped"]);
+var RuleEvaluationResult = z5.object({
+  ruleId: z5.string(),
+  ruleKey: z5.string(),
+  ruleVersion: z5.number().int(),
+  severity: RuleSeverity,
+  weight: z5.number().nullish(),
+  outcome: RuleOutcome,
+  score: z5.number().nullish(),
+  reasons: z5.array(z5.string()),
+  details: z5.unknown().optional(),
+  durationMs: z5.number().nonnegative(),
+  /** Evaluated as a shadow rule of a rule set: recorded, but excluded from aggregation. */
+  shadow: z5.boolean().optional()
+});
+
+// src/decision.ts
+import { z as z6 } from "zod";
+var DecisionOutcome = z6.enum(["approve", "reject", "manual_review"]);
+var DecisionReason = z6.object({
+  code: z6.string().min(1),
+  message: z6.string(),
+  ruleKey: z6.string().optional()
+});
+var DecisionSource = z6.enum(["automated", "manual"]);
+var Decision = z6.object({
+  id: Id,
+  tenantId: Id,
+  subjectId: Id,
+  workflowRunId: Id.nullish(),
+  caseId: Id.nullish(),
+  outcome: DecisionOutcome,
+  riskScore: z6.number().nullish(),
+  reasons: z6.array(DecisionReason),
+  source: DecisionSource,
+  decidedBy: z6.string().nullish(),
+  ruleResults: z6.array(RuleEvaluationResult),
+  /** The rule set that produced an automated decision, when one was used. */
+  ruleSetKey: z6.string().nullish(),
+  ruleSetVersion: z6.number().int().nullish(),
+  createdAt: z6.coerce.date()
+});
+
+// src/case.ts
+import { z as z7 } from "zod";
+var CaseStatus = z7.enum(["open", "in_review", "decided", "closed"]);
+var CasePriority = z7.enum(["low", "medium", "high", "critical"]);
+var CaseSlaState = z7.enum(["none", "ok", "due_soon", "breached"]);
+var Case = BaseEntity.extend({
+  subjectId: Id,
+  workflowRunId: Id.nullish(),
+  type: z7.string().min(1),
+  status: CaseStatus,
+  priority: CasePriority,
+  assigneeId: z7.string().nullish(),
+  decisionId: Id.nullish(),
+  context: JsonObject,
+  /** SLA deadline, set from the step's `slaHours` or the tenant default. */
+  dueAt: z7.coerce.date().nullish(),
+  /** Set once by the workflow when the SLA timer fires before a decision. */
+  slaBreachedAt: z7.coerce.date().nullish(),
+  /** First assignment or note: the moment someone picked the case up. */
+  firstResponseAt: z7.coerce.date().nullish(),
+  decidedAt: z7.coerce.date().nullish(),
+  closedAt: z7.coerce.date().nullish(),
+  closedReason: z7.string().nullish()
+});
+var CaseView = Case.extend({ slaState: CaseSlaState });
+function caseSlaState(c, now = /* @__PURE__ */ new Date()) {
+  if (!c.dueAt) return "none";
+  if (c.slaBreachedAt) return "breached";
+  if (c.status === "decided" || c.status === "closed") return "ok";
+  const remaining = c.dueAt.getTime() - now.getTime();
+  if (remaining <= 0) return "breached";
+  const window = c.dueAt.getTime() - c.createdAt.getTime();
+  const soon = Math.min(window * 0.5, Math.max(window * 0.2, 2 * 3600 * 1e3));
+  return remaining <= soon ? "due_soon" : "ok";
+}
+var AssignCaseInput = z7.object({
+  /** Reviewer id from the user directory; `null` unassigns. */
+  assigneeId: z7.string().min(1).nullable()
+});
+var CloseCaseInput = z7.object({ reason: z7.string().max(500).optional() });
+var CaseNote = BaseEntity.extend({
+  caseId: Id,
+  authorId: z7.string().min(1),
+  body: z7.string().min(1).max(1e4),
+  editedAt: z7.coerce.date().nullish()
+});
+var CaseNoteInput = z7.object({ body: z7.string().min(1).max(1e4) });
+var CaseSort = z7.enum(["createdAt", "dueAt", "priority"]);
+var SortOrder = z7.enum(["asc", "desc"]);
+var CaseFilter = z7.object({
+  status: z7.array(CaseStatus).optional(),
+  priority: z7.array(CasePriority).optional(),
+  /** A reviewer id, `me` (resolved to the caller) or `unassigned`. */
+  assignee: z7.string().min(1).optional(),
+  type: z7.string().min(1).optional(),
+  subjectId: Id.optional(),
+  slaState: z7.array(CaseSlaState).optional(),
+  dueBefore: z7.coerce.date().optional(),
+  /** Case-insensitive match on `context.subjectName` and the case type. */
+  search: z7.string().min(1).max(200).optional()
+});
+var CaseQueue = BaseEntity.extend({
+  name: z7.string().min(1).max(80),
+  filter: CaseFilter,
+  sort: CaseSort,
+  order: SortOrder,
+  position: z7.number().int().nonnegative(),
+  createdBy: z7.string().min(1)
+});
+var UpsertCaseQueueInput = z7.object({
+  name: z7.string().min(1).max(80),
+  filter: CaseFilter.default({}),
+  sort: CaseSort.default("createdAt"),
+  order: SortOrder.default("desc"),
+  position: z7.number().int().nonnegative().default(0)
+});
+var DecideCaseInput = z7.object({
+  outcome: DecisionOutcome,
+  reasons: z7.array(DecisionReason).default([]),
+  note: z7.string().optional()
+});
+var ManualDecision = z7.object({
+  caseId: Id,
+  decisionId: Id,
+  outcome: DecisionOutcome,
+  reasons: z7.array(DecisionReason),
+  decidedBy: z7.string()
+});
+
+// src/workflow.ts
+import { z as z8 } from "zod";
+var StepBase = z8.object({
+  id: z8.string().min(1),
+  name: z8.string().optional(),
+  /** Next step id. Omitted on terminal steps. */
+  next: z8.string().optional()
+});
+var EvaluateRulesStep = StepBase.extend({
+  type: z8.literal("evaluate_rules"),
+  /** Ad-hoc list evaluated with the default policy; mutually exclusive with `ruleSetKey`. */
+  ruleKeys: z8.array(DefinitionKey).min(1).optional(),
+  /** A published rule set: its rules, order, overrides and aggregation policy. */
+  ruleSetKey: DefinitionKey.optional(),
+  outputKey: z8.string().default("rules")
+}).refine((step) => step.ruleKeys === void 0 !== (step.ruleSetKey === void 0), {
+  message: "evaluate_rules needs exactly one of ruleKeys or ruleSetKey",
+  path: ["ruleKeys"]
+});
+var CallPluginStep = StepBase.extend({
+  type: z8.literal("call_plugin"),
+  plugin: z8.string().min(1),
+  action: z8.string().min(1),
+  /** Literal input values (e.g. `{ type: "Person", topics: ["role.pep"] }`); `inputMapping` entries override them. */
+  input: z8.record(z8.string(), z8.unknown()).default({}),
+  /** input field -> dot path into the run context (e.g. `{ name: "submission.data.legalName" }`). */
+  inputMapping: z8.record(z8.string(), z8.string()).default({}),
+  outputKey: z8.string().min(1),
+  /** Overrides the worker's default retry policy for this plugin call. */
+  retry: z8.object({
+    maximumAttempts: z8.number().int().min(1).max(10).optional(),
+    initialIntervalSeconds: z8.number().positive().optional()
+  }).optional()
+});
+var WaitForCollectionStep = StepBase.extend({
+  type: z8.literal("wait_for_collection"),
+  flowKey: DefinitionKey,
+  timeoutSeconds: z8.number().int().positive().optional(),
+  outputKey: z8.string().default("submission")
+});
+var CreateCaseStep = StepBase.extend({
+  type: z8.literal("create_case"),
+  caseType: z8.string().min(1),
+  priority: CasePriority.default("medium"),
+  /** Hours until the case's SLA deadline; the tenant default applies when omitted. */
+  slaHours: z8.number().positive().max(24 * 90).optional(),
+  outputKey: z8.string().default("manualDecision")
+});
+var EmitDecisionStep = StepBase.extend({
+  type: z8.literal("emit_decision"),
+  mode: z8.enum(["from_rules", "fixed"]).default("from_rules"),
+  /** Context key holding rule results when mode is `from_rules`. */
+  rulesKey: z8.string().default("rules"),
+  /** Context key holding a manual decision; takes precedence when present. */
+  manualDecisionKey: z8.string().default("manualDecision"),
+  outcome: DecisionOutcome.optional()
+});
+var BranchStep = StepBase.extend({
+  type: z8.literal("branch"),
+  conditions: z8.array(z8.object({ when: Condition, next: z8.string().min(1) })).min(1),
+  default: z8.string().min(1)
+});
+var WorkflowStep = z8.discriminatedUnion("type", [
+  EvaluateRulesStep,
+  CallPluginStep,
+  WaitForCollectionStep,
+  CreateCaseStep,
+  EmitDecisionStep,
+  BranchStep
+]);
+function stepTargets(step) {
+  const targets = step.next ? [step.next] : [];
+  if (step.type === "branch") {
+    targets.push(...step.conditions.map((c) => c.next), step.default);
+  }
+  return targets;
+}
+var WorkflowUi = z8.object({
+  positions: z8.record(z8.string(), z8.object({ x: z8.number(), y: z8.number() })).default({})
+});
+var WorkflowDefinitionBody = z8.object({
+  entryStepId: z8.string().min(1),
+  steps: z8.array(WorkflowStep).min(1),
+  ui: WorkflowUi.optional()
+}).superRefine((body, ctx) => {
+  const ids = /* @__PURE__ */ new Set();
+  body.steps.forEach((step, index) => {
+    if (ids.has(step.id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["steps", index, "id"],
+        message: `duplicate step id "${step.id}"`
+      });
+    }
+    ids.add(step.id);
+  });
+  if (!ids.has(body.entryStepId)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["entryStepId"],
+      message: `unknown entry step "${body.entryStepId}"`
+    });
+  }
+  body.steps.forEach((step, index) => {
+    for (const target of stepTargets(step)) {
+      if (!ids.has(target)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["steps", index],
+          message: `step "${step.id}" points to unknown step "${target}"`
+        });
+      }
+    }
+  });
+});
+var WorkflowTrigger = z8.enum(["manual", "subject.created", "event"]);
+var WorkflowDefinition = BaseEntity.extend({
+  /** Actor id that created this version; null for rows older than PR 19. */
+  createdBy: z8.string().nullish(),
+  key: DefinitionKey,
+  version: z8.number().int().positive(),
+  name: z8.string().min(1),
+  description: z8.string().nullish(),
+  trigger: WorkflowTrigger,
+  status: DefinitionStatus,
+  definition: WorkflowDefinitionBody
+});
+var UpsertWorkflowDefinitionInput = z8.object({
+  name: z8.string().min(1),
+  description: z8.string().optional(),
+  trigger: WorkflowTrigger.default("manual"),
+  definition: WorkflowDefinitionBody
+});
+var WorkflowRunStatus = z8.enum([
+  "running",
+  "waiting_collection",
+  "waiting_manual",
+  "waiting_callback",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var WorkflowRun = BaseEntity.extend({
+  definitionId: Id,
+  definitionKey: DefinitionKey,
+  definitionVersion: z8.number().int().positive(),
+  subjectId: Id,
+  temporalWorkflowId: z8.string(),
+  temporalRunId: z8.string().nullish(),
+  status: WorkflowRunStatus,
+  currentStepId: z8.string().nullish(),
+  /** Accumulated step outputs keyed by each step's `outputKey`. */
+  context: JsonObject,
+  decisionId: Id.nullish(),
+  error: z8.string().nullish(),
+  startedAt: z8.coerce.date(),
+  finishedAt: z8.coerce.date().nullish()
+});
+var StartWorkflowRunInput = z8.object({
+  definitionKey: DefinitionKey,
+  subjectId: Id
+});
+var RunDefinitionInput = z8.object({
+  tenantId: Id,
+  runId: Id,
+  definitionId: Id,
+  definitionVersion: z8.number().int().positive(),
+  subjectId: Id
+});
+function temporalWorkflowId(tenantId, runId) {
+  return `wf:${tenantId}:${runId}`;
+}
+
+// src/plugin.ts
+import { z as z9 } from "zod";
+var PluginDefinition = BaseEntity.extend({
+  name: z9.string().min(1),
+  version: z9.string().min(1),
+  capabilities: z9.array(z9.string()),
+  enabled: z9.boolean(),
+  config: JsonObject,
+  /** secret name -> reference understood by the SecretProvider (e.g. env var name). */
+  secretRefs: z9.record(z9.string(), z9.string())
+});
+var PluginInvocationStatus = z9.enum(["success", "error", "timeout", "pending"]);
+var PluginInvocation = z9.object({
+  id: Id,
+  tenantId: Id,
+  pluginName: z9.string(),
+  action: z9.string(),
+  subjectId: Id.nullish(),
+  workflowRunId: Id.nullish(),
+  input: z9.unknown(),
+  output: z9.unknown().nullish(),
+  status: PluginInvocationStatus,
+  error: z9.string().nullish(),
+  durationMs: z9.number().nonnegative(),
+  invokedAt: z9.coerce.date(),
+  /** Caller-provided key identifying the logical call across retries. */
+  idempotencyKey: z9.string().nullish(),
+  /** 1 for the first attempt of a logical call, incremented by runtime retries. */
+  attempt: z9.number().int().positive().default(1)
+});
+var ConfigurePluginInput = z9.object({
+  enabled: z9.boolean().default(true),
+  config: JsonObject.default({}),
+  secretRefs: z9.record(z9.string(), z9.string()).default({})
+});
+
+// src/collection.ts
+import { z as z10 } from "zod";
+var FieldType = z10.enum(["text", "email", "number", "select", "date", "boolean", "file"]);
+var FieldOption = z10.object({ value: z10.string(), label: z10.string() });
+var FieldValidation = z10.object({
+  min: z10.number().optional(),
+  max: z10.number().optional(),
+  pattern: z10.string().optional()
+});
+var Field = z10.object({
+  key: z10.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/, "field keys are identifiers"),
+  label: z10.string().min(1),
+  type: FieldType,
+  required: z10.boolean().default(false),
+  placeholder: z10.string().optional(),
+  help: z10.string().optional(),
+  options: z10.array(FieldOption).optional(),
+  validation: FieldValidation.optional(),
+  /** Field is rendered and validated only when the condition holds against the submission data. */
+  visibleWhen: Condition.optional()
+});
+var FlowStep = z10.object({
+  id: z10.string().min(1),
+  title: z10.string().min(1),
+  description: z10.string().optional(),
+  fields: z10.array(Field),
+  next: z10.string().optional(),
+  branches: z10.array(z10.object({ when: Condition, next: z10.string().min(1) })).optional()
+});
+var DEFAULT_LINK_TTL_SECONDS = 7 * 24 * 3600;
+var MAX_LINK_TTL_SECONDS = 30 * 24 * 3600;
+var CollectionFlowBody = z10.object({
+  entryStepId: z10.string().min(1),
+  steps: z10.array(FlowStep).min(1),
+  /** Lifetime of the signed submission link issued for this flow (60 s to 30 days). */
+  linkTtlSeconds: z10.number().int().min(60).max(MAX_LINK_TTL_SECONDS).default(DEFAULT_LINK_TTL_SECONDS)
+}).superRefine((body, ctx) => {
+  const ids = new Set(body.steps.map((s) => s.id));
+  if (ids.size !== body.steps.length) {
+    ctx.addIssue({ code: "custom", path: ["steps"], message: "duplicate step ids" });
+  }
+  if (!ids.has(body.entryStepId)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["entryStepId"],
+      message: `unknown entry step "${body.entryStepId}"`
+    });
+  }
+  body.steps.forEach((step, index) => {
+    const targets = [
+      ...step.next ? [step.next] : [],
+      ...(step.branches ?? []).map((b) => b.next)
+    ];
+    for (const target of targets) {
+      if (!ids.has(target)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["steps", index],
+          message: `step "${step.id}" points to unknown step "${target}"`
+        });
+      }
+    }
+  });
+});
+var CollectionFlowDefinition = BaseEntity.extend({
+  /** Actor id that created this version; null for rows older than PR 19. */
+  createdBy: z10.string().nullish(),
+  key: DefinitionKey,
+  version: z10.number().int().positive(),
+  name: z10.string().min(1),
+  description: z10.string().nullish(),
+  status: DefinitionStatus,
+  definition: CollectionFlowBody
+});
+var UpsertCollectionFlowInput = z10.object({
+  name: z10.string().min(1),
+  description: z10.string().optional(),
+  definition: CollectionFlowBody
+});
+var SubmissionStatus = z10.enum(["in_progress", "submitted"]);
+var CollectionSubmission = BaseEntity.extend({
+  flowDefinitionId: Id,
+  flowKey: DefinitionKey,
+  flowVersion: z10.number().int().positive(),
+  subjectId: Id,
+  workflowRunId: Id.nullish(),
+  status: SubmissionStatus,
+  data: JsonObject,
+  currentStepId: z10.string().nullish(),
+  submittedAt: z10.coerce.date().nullish()
+});
+var CreateSubmissionInput = z10.object({
+  flowKey: DefinitionKey,
+  subjectId: Id,
+  workflowRunId: Id.optional()
+});
+var SaveSubmissionInput = z10.object({
+  data: JsonObject,
+  currentStepId: z10.string().optional()
+});
+var CollectionSubmitted = z10.object({
+  submissionId: Id,
+  flowKey: DefinitionKey,
+  data: JsonObject,
+  submittedAt: z10.coerce.date()
+});
+
+// src/audit.ts
+import { z as z11 } from "zod";
+var AuditEvent = z11.object({
+  id: Id,
+  tenantId: Id,
+  actorType: ActorType,
+  actorId: z11.string(),
+  /** Dotted verb, e.g. `case.decided`, `workflow.step.completed`. */
+  action: z11.string().regex(/^[a-z_]+(\.[a-z_]+)+$/),
+  resourceType: z11.string().min(1),
+  resourceId: z11.string().min(1),
+  payload: z11.unknown(),
+  occurredAt: z11.coerce.date()
+});
+
+// src/list.ts
+import { z as z12 } from "zod";
+var ListKind = z12.enum(["string", "email", "country", "ip_cidr", "number"]);
+var List = BaseEntity.extend({
+  key: DefinitionKey,
+  name: z12.string().min(1),
+  description: z12.string().nullish(),
+  kind: ListKind,
+  /** String matching ignores case (default). Ignored for `ip_cidr` and `number`. */
+  caseInsensitive: z12.boolean(),
+  entryCount: z12.number().int().nonnegative()
+});
+var UpsertListInput = z12.object({
+  name: z12.string().min(1),
+  description: z12.string().optional(),
+  kind: ListKind,
+  caseInsensitive: z12.boolean().default(true)
+});
+var ListEntry = z12.object({
+  id: Id,
+  tenantId: Id,
+  listId: Id,
+  /** The value as entered (trimmed). Matching uses a normalised form. */
+  value: z12.string().min(1),
+  reason: z12.string().nullish(),
+  expiresAt: z12.coerce.date().nullish(),
+  addedBy: z12.string(),
+  createdAt: z12.coerce.date()
+});
+var NewListEntry = z12.object({
+  value: z12.string().trim().min(1).max(512),
+  reason: z12.string().max(1e3).optional(),
+  expiresAt: z12.coerce.date().optional()
+});
+var AddListEntriesInput = z12.object({
+  entries: z12.array(NewListEntry).min(1).max(1e4)
+});
+var RemoveListEntriesInput = z12.object({
+  ids: z12.array(Id).min(1).max(1e4)
+});
+var ListImportResult = z12.object({
+  added: z12.number().int().nonnegative(),
+  skipped: z12.number().int().nonnegative(),
+  invalid: z12.array(
+    z12.object({ line: z12.number().int().positive(), value: z12.string(), reason: z12.string() })
+  )
+});
+var IPV4 = /^(\d{1,3})(\.\d{1,3}){3}(\/\d{1,2})?$/;
+var IPV6 = /^[0-9a-f:]+(\/\d{1,3})?$/i;
+var COUNTRY = /^[A-Z]{2}$/;
+function normalizeListValue(kind, raw, caseInsensitive = true) {
+  const value = raw.trim();
+  if (!value) return { ok: false, reason: "empty value" };
+  switch (kind) {
+    case "string":
+      return { ok: true, value: caseInsensitive ? value.toLowerCase() : value };
+    case "email": {
+      const lower = value.toLowerCase();
+      if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(lower))
+        return { ok: false, reason: "not an email address" };
+      return { ok: true, value: lower };
+    }
+    case "country": {
+      const upper = value.toUpperCase();
+      if (!COUNTRY.test(upper)) return { ok: false, reason: "not an ISO 3166-1 alpha-2 code" };
+      return { ok: true, value: upper };
+    }
+    case "number": {
+      const n = Number(value);
+      if (!Number.isFinite(n)) return { ok: false, reason: "not a number" };
+      return { ok: true, value: String(n) };
+    }
+    case "ip_cidr": {
+      if (IPV4.test(value)) {
+        const [addr, prefix] = value.split("/");
+        const octets = addr.split(".").map(Number);
+        if (octets.some((o) => o > 255)) return { ok: false, reason: "invalid IPv4 address" };
+        if (prefix !== void 0 && Number(prefix) > 32)
+          return { ok: false, reason: "invalid prefix" };
+        return { ok: true, value: prefix === void 0 ? `${addr}/32` : value };
+      }
+      if (IPV6.test(value) && value.includes(":")) {
+        const [addr, prefix] = value.split("/");
+        if (prefix !== void 0 && Number(prefix) > 128)
+          return { ok: false, reason: "invalid prefix" };
+        return {
+          ok: true,
+          value: prefix === void 0 ? `${addr.toLowerCase()}/128` : value.toLowerCase()
+        };
+      }
+      return { ok: false, reason: "not an IP address or CIDR range" };
+    }
+  }
+}
+
+// src/event.ts
+import { z as z13 } from "zod";
+var EventKey = z13.enum(["ip", "device_id", "card_fingerprint", "email"]);
+var Event = z13.object({
+  id: z13.string(),
+  tenantId: Id,
+  subjectId: Id,
+  type: z13.string().min(1),
+  amount: z13.number().nullish(),
+  currency: z13.string().length(3).nullish(),
+  occurredAt: z13.coerce.date(),
+  ingestedAt: z13.coerce.date(),
+  attributes: JsonObject,
+  idempotencyKey: z13.string(),
+  ip: z13.string().nullish(),
+  deviceId: z13.string().nullish(),
+  cardFingerprint: z13.string().nullish(),
+  email: z13.string().nullish()
+});
+var NewEvent = z13.object({
+  subjectId: Id,
+  type: z13.string().min(1).max(100).regex(/^[a-z0-9][a-z0-9_.-]*$/, "event types are lowercase identifiers"),
+  amount: z13.number().finite().optional(),
+  currency: z13.string().length(3).toUpperCase().optional(),
+  occurredAt: z13.coerce.date(),
+  attributes: JsonObject.default({}),
+  /** Caller-chosen key; re-sending the same key is a no-op. */
+  idempotencyKey: z13.string().min(1).max(255),
+  ip: z13.string().max(45).optional(),
+  deviceId: z13.string().max(255).optional(),
+  cardFingerprint: z13.string().max(255).optional(),
+  email: z13.string().max(320).toLowerCase().optional()
+});
+var IngestEventsInput = z13.object({
+  events: z13.array(NewEvent).min(1).max(1e3)
+});
+var IngestEventsResult = z13.object({
+  accepted: z13.number().int().nonnegative(),
+  duplicates: z13.number().int().nonnegative()
+});
+
+// src/rule-set.ts
+import { z as z14 } from "zod";
+var RuleSetUseCase = z14.enum(["onboarding", "underwriting", "monitoring", "custom"]);
+var ScoreBand = z14.object({
+  min: z14.number(),
+  max: z14.number(),
+  outcome: DecisionOutcome
+});
+var ScoreClamp = z14.object({ min: z14.number().default(0), max: z14.number().default(100) });
+var AggregationPolicy = z14.discriminatedUnion("mode", [
+  /** Failed block -> reject; failed warn -> manual review; else approve (the original policy). */
+  z14.object({ mode: z14.literal("max_severity") }),
+  /** Score = sum of weights on failed rules plus reported scores, clamped, mapped through bands. */
+  z14.object({
+    mode: z14.literal("sum_weights"),
+    clamp: ScoreClamp.default({ min: 0, max: 100 }),
+    bands: z14.array(ScoreBand).min(1)
+  }),
+  /** Rules in set order; the first failed rule's severity decides, `info` continues. */
+  z14.object({ mode: z14.literal("first_match"), default: DecisionOutcome.default("approve") })
+]);
+var RuleSetRule = z14.object({
+  ruleKey: DefinitionKey,
+  enabled: z14.boolean().default(true),
+  /** Replaces the rule's own weight inside this set. */
+  weightOverride: z14.number().optional(),
+  /** Evaluated and recorded but excluded from aggregation. */
+  shadow: z14.boolean().default(false)
+});
+var RuleSetBody = z14.object({
+  rules: z14.array(RuleSetRule).min(1),
+  policy: AggregationPolicy
+}).superRefine((body, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  body.rules.forEach((rule, index) => {
+    if (seen.has(rule.ruleKey)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["rules", index, "ruleKey"],
+        message: `duplicate rule "${rule.ruleKey}"`
+      });
+    }
+    seen.add(rule.ruleKey);
+  });
+  if (body.policy.mode !== "sum_weights") return;
+  const { clamp, bands } = body.policy;
+  if (clamp.min >= clamp.max) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["policy", "clamp"],
+      message: "clamp.min must be below clamp.max"
+    });
+    return;
+  }
+  const sorted = [...bands].sort((a, b) => a.min - b.min);
+  let expected = clamp.min;
+  sorted.forEach((band, index) => {
+    if (band.min >= band.max) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["policy", "bands", index],
+        message: "band.min must be below band.max"
+      });
+    }
+    if (band.min !== expected) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["policy", "bands", index],
+        message: `bands must be contiguous and start at ${clamp.min}; expected min ${expected}, got ${band.min}`
+      });
+    }
+    expected = band.max;
+  });
+  if (expected !== clamp.max) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["policy", "bands"],
+      message: `bands must end at clamp.max (${clamp.max}), got ${expected}`
+    });
+  }
+});
+var RuleSetDefinition = BaseEntity.extend({
+  /** Actor id that created this version; null for rows older than PR 19. */
+  createdBy: z14.string().nullish(),
+  key: DefinitionKey,
+  version: z14.number().int().positive(),
+  name: z14.string().min(1),
+  description: z14.string().nullish(),
+  useCase: RuleSetUseCase,
+  status: DefinitionStatus,
+  definition: RuleSetBody
+});
+var UpsertRuleSetInput = z14.object({
+  name: z14.string().min(1),
+  description: z14.string().optional(),
+  useCase: RuleSetUseCase.default("custom"),
+  definition: RuleSetBody
+});
+function bandFor(bands, score) {
+  const sorted = [...bands].sort((a, b) => a.min - b.min);
+  const last = sorted[sorted.length - 1];
+  for (const band of sorted) {
+    if (score >= band.min && (score < band.max || band === last && score <= band.max))
+      return band;
+  }
+  return void 0;
+}
+
+// src/evaluation.ts
+import { z as z15 } from "zod";
+var RuleEvaluation = z15.object({
+  id: Id,
+  tenantId: Id,
+  workflowRunId: Id,
+  stepId: z15.string(),
+  subjectId: Id,
+  ruleSetKey: z15.string().nullish(),
+  ruleSetVersion: z15.number().int().nullish(),
+  ruleKeys: z15.array(z15.string()),
+  /** The full `RuleContext.data` at evaluation time. */
+  data: JsonObject,
+  results: z15.array(RuleEvaluationResult),
+  outcome: DecisionOutcome,
+  riskScore: z15.number(),
+  evaluatedAt: z15.coerce.date()
+});
+
+// src/backtest.ts
+import { z as z16 } from "zod";
+var BacktestStatus = z16.enum(["queued", "running", "completed", "failed"]);
+var BacktestSample = z16.object({
+  /** Replay evaluations recorded in the last N days (at most 180). */
+  lastDays: z16.number().int().min(1).max(180).default(30),
+  /** Newest evaluation per subject, up to this many subjects. */
+  limit: z16.number().int().min(1).max(5e3).default(1e3)
+});
+var StartBacktestInput = z16.object({
+  ruleKey: DefinitionKey,
+  /** Defaults to the latest version (drafts included). */
+  version: z16.number().int().positive().optional(),
+  sample: BacktestSample.default({ lastDays: 30, limit: 1e3 }),
+  /**
+   * Re-aggregate each stored evaluation with the draft rule's result substituted (or added) under
+   * this rule set's policy, to report how outcomes would change.
+   */
+  compareWithRuleSetKey: DefinitionKey.optional()
+});
+var BacktestProgress = z16.object({
+  done: z16.number().int().nonnegative(),
+  total: z16.number().int().nonnegative()
+});
+var BacktestSampleFailure = z16.object({
+  evaluationId: Id,
+  subjectId: Id,
+  evaluatedAt: z16.coerce.date(),
+  reasons: z16.array(z16.string())
+});
+var BacktestSummary = z16.object({
+  evaluated: z16.number().int().nonnegative(),
+  outcomes: z16.record(RuleOutcome, z16.number().int().nonnegative()),
+  /** Counts keyed `"<before>-><after>"` for evaluations whose aggregate outcome would change. */
+  wouldChange: z16.record(z16.string(), z16.number().int().nonnegative()),
+  /** Per existing rule key: evaluations where both that rule and the draft failed. */
+  overlap: z16.record(z16.string(), z16.number().int().nonnegative()),
+  /** First 50 evaluations the draft failed on. */
+  sampleFailures: z16.array(BacktestSampleFailure),
+  durationMs: z16.number().nonnegative()
+});
+var Backtest = z16.object({
+  id: Id,
+  tenantId: Id,
+  ruleKey: DefinitionKey,
+  ruleVersion: z16.number().int().positive(),
+  ruleSetKey: z16.string().nullish(),
+  sample: BacktestSample,
+  status: BacktestStatus,
+  progress: BacktestProgress,
+  summary: BacktestSummary.nullish(),
+  error: z16.string().nullish(),
+  temporalWorkflowId: z16.string().nullish(),
+  requestedBy: z16.string(),
+  createdAt: z16.coerce.date(),
+  finishedAt: z16.coerce.date().nullish()
+});
+var OutcomeChange = z16.object({ before: DecisionOutcome, after: DecisionOutcome });
+
+// src/plugin-callback.ts
+import { z as z17 } from "zod";
+var PluginCallbackStatus = z17.enum(["pending", "completed", "failed", "timed_out"]);
+var PluginCallback = z17.object({
+  id: Id,
+  tenantId: Id,
+  pluginName: z17.string(),
+  action: z17.string(),
+  externalId: z17.string(),
+  workflowRunId: Id.nullish(),
+  stepId: z17.string().nullish(),
+  status: PluginCallbackStatus,
+  output: z17.unknown().nullish(),
+  error: z17.string().nullish(),
+  createdAt: z17.coerce.date(),
+  completedAt: z17.coerce.date().nullish()
+});
+var PluginCallbackSignal = z17.object({
+  externalId: z17.string(),
+  status: z17.enum(["completed", "failed"]),
+  output: z17.unknown().optional(),
+  error: z17.string().optional()
+});
+var WebhookEventRecord = z17.object({
+  id: Id,
+  tenantId: Id,
+  pluginName: z17.string(),
+  eventId: z17.string(),
+  externalId: z17.string(),
+  receivedAt: z17.coerce.date()
+});
+
+// src/document.ts
+import { z as z18 } from "zod";
+var DOCUMENT_MAX_BYTES = 20 * 1024 * 1024;
+var DOCUMENT_CONTENT_TYPES = [
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "application/pdf"
+];
+var DocumentContentType = z18.enum(DOCUMENT_CONTENT_TYPES);
+var DocumentStatus = z18.enum([
+  "pending",
+  "uploaded",
+  "scanning",
+  "clean",
+  "infected",
+  "rejected"
+]);
+var DOCUMENT_OPEN_STATUSES = [
+  "pending",
+  "uploaded",
+  "scanning"
+];
+var DocumentScan = z18.object({
+  /** Scanner that produced the verdict, e.g. `none`, `clamav`. */
+  engine: z18.string().min(1),
+  /** Malware signature name when infected. */
+  signature: z18.string().optional(),
+  scannedAt: z18.coerce.date()
+});
+var Document = BaseEntity.extend({
+  subjectId: Id,
+  submissionId: Id.nullish(),
+  caseId: Id.nullish(),
+  /** Collection-flow field the file was uploaded for. */
+  fieldKey: z18.string().nullish(),
+  fileName: z18.string().min(1).max(255),
+  /** Declared on creation; replaced by the sniffed type on finalize. */
+  contentType: z18.string().min(1),
+  sizeBytes: z18.number().int().nonnegative(),
+  /** Hex digest, set on finalize. */
+  sha256: z18.string().nullish(),
+  /** Server-chosen object key: `${tenantId}/${subjectId}/${documentId}`. */
+  storageKey: z18.string().min(1),
+  status: DocumentStatus,
+  scan: DocumentScan.nullish(),
+  /** Why the document was `rejected`, for operators and applicants. */
+  rejectionReason: z18.string().nullish(),
+  /** Actor id of the uploader (user id, machine id or submission id). */
+  uploadedBy: z18.string().min(1)
+});
+var CreateDocumentInput = z18.object({
+  fileName: z18.string().min(1).max(255),
+  contentType: DocumentContentType,
+  sizeBytes: z18.number().int().positive().max(DOCUMENT_MAX_BYTES),
+  /** Operators and integrations name the subject; applicants' subject comes from the submission. */
+  subjectId: Id.optional(),
+  submissionId: Id.optional(),
+  caseId: Id.optional(),
+  fieldKey: z18.string().optional()
+});
+var DocumentUploadTicket = z18.object({
+  documentId: Id,
+  upload: z18.object({
+    url: z18.url(),
+    /** Form fields to send with the file (policy, signature, key); the file field goes last. */
+    fields: z18.record(z18.string(), z18.string()),
+    expiresAt: z18.coerce.date(),
+    maxBytes: z18.number().int().positive()
+  })
+});
+var DocumentDownload = z18.object({
+  url: z18.url(),
+  expiresAt: z18.coerce.date(),
+  fileName: z18.string(),
+  contentType: z18.string()
+});
+var FileFieldValue = z18.object({ fileId: Id, name: z18.string().optional() });
+
+// src/timeline.ts
+import { z as z19 } from "zod";
+var TimelineKind = z19.enum([
+  "decision",
+  "case",
+  "run",
+  "submission",
+  "document",
+  "event",
+  "note",
+  "audit"
+]);
+var TimelineEntry = z19.object({
+  /** Stable per entry: `<kind>:<resourceId>[:<suffix>]`. */
+  id: z19.string().min(1),
+  kind: TimelineKind,
+  at: z19.coerce.date(),
+  title: z19.string().min(1),
+  summary: z19.string().optional(),
+  resourceType: z19.string().min(1),
+  resourceId: z19.string().min(1),
+  actor: Actor.optional(),
+  data: z19.unknown().optional()
+});
+var TimelineQuery = z19.object({
+  from: z19.coerce.date().optional(),
+  to: z19.coerce.date().optional(),
+  kinds: z19.array(TimelineKind).optional(),
+  limit: z19.coerce.number().int().positive().max(500).optional(),
+  offset: z19.coerce.number().int().nonnegative().optional()
+});
+
+// src/builder.ts
+import { z as z20 } from "zod";
+var FormUiHints = z20.object({
+  /** Fields in display order; unlisted fields follow in schema order. */
+  fieldOrder: z20.array(z20.string()).optional(),
+  labels: z20.record(z20.string(), z20.string()).optional(),
+  help: z20.record(z20.string(), z20.string()).optional(),
+  /**
+   * Fields rendered with a picker instead of a free input. Values: `list`, `rule`, `ruleSet`,
+   * `flow`, `plugin`, `pluginAction`, `step`, `path`, `condition`, `cel`.
+   */
+  pickers: z20.record(z20.string(), z20.string()).optional()
+});
+var StepTypeDescription = z20.object({
+  type: z20.string().min(1),
+  title: z20.string().min(1),
+  description: z20.string(),
+  /** JSON Schema of the step's own fields (`id`, `name`, `next` excluded). */
+  configSchema: z20.unknown(),
+  /** Dot-path namespaces the step may read from the run context, e.g. `submission.<field>`. */
+  dataPaths: z20.array(z20.string()).default([]),
+  /** Context keys the step writes (`outputKey` conventions), for downstream path pickers. */
+  outputs: z20.array(z20.string()).default([]),
+  /** Whether the step ends the run (no `next`). */
+  terminal: z20.boolean().default(false),
+  uiHints: FormUiHints.optional()
+});
+var FieldTypeDescription = z20.object({
+  type: z20.string().min(1),
+  title: z20.string().min(1),
+  description: z20.string(),
+  /** JSON Schema of the field-type-specific options (select options, validation, file limits). */
+  optionsSchema: z20.unknown(),
+  /** Shape of the stored value, as JSON Schema, for previews and docs. */
+  valueSchema: z20.unknown()
+});
+var IssueSeverity = z20.enum(["error", "warning"]);
+var DefinitionIssue = z20.object({
+  severity: IssueSeverity,
+  /** JSON pointer-ish path into the body, e.g. `steps.2.next`. */
+  path: z20.string(),
+  /** Step or field the issue belongs to, when it has one, so editors can mark it. */
+  stepId: z20.string().optional(),
+  fieldKey: z20.string().optional(),
+  code: z20.string().min(1),
+  message: z20.string().min(1)
+});
+var ValidationReport = z20.object({
+  ok: z20.boolean(),
+  issues: z20.array(DefinitionIssue)
+});
+
+// src/governance.ts
+import { z as z21 } from "zod";
+var DefinitionKind = z21.enum(["workflow", "rule", "rule_set", "collection_flow"]);
+var DEFINITION_PATHS = {
+  workflow: "/workflow-definitions",
+  rule: "/rule-definitions",
+  rule_set: "/rule-sets",
+  collection_flow: "/collection-flows"
+};
+var ApprovalDecision = z21.enum(["approved", "rejected"]);
+var DefinitionApproval = z21.object({
+  id: Id,
+  tenantId: Id,
+  kind: DefinitionKind,
+  key: DefinitionKey,
+  version: z21.number().int().positive(),
+  requestedBy: z21.string().min(1),
+  requestedAt: z21.coerce.date(),
+  comment: z21.string().nullish(),
+  decidedBy: z21.string().nullish(),
+  decidedAt: z21.coerce.date().nullish(),
+  decision: ApprovalDecision.nullish(),
+  decisionComment: z21.string().nullish()
+});
+var ApprovalCommentInput = z21.object({ comment: z21.string().max(2e3).optional() });
+var DefinitionVersionSummary = z21.object({
+  kind: DefinitionKind,
+  key: DefinitionKey,
+  version: z21.number().int().positive(),
+  status: DefinitionStatus,
+  name: z21.string(),
+  createdBy: z21.string().nullish(),
+  createdAt: z21.coerce.date(),
+  updatedAt: z21.coerce.date(),
+  /** The open or latest approval for this version, when any. */
+  approval: DefinitionApproval.nullish()
+});
+var DiffOp = z21.enum(["added", "removed", "changed", "moved"]);
+var DiffChange = z21.object({
+  op: DiffOp,
+  /** Dotted path into the compared document, e.g. `definition.steps.idv.next`. */
+  path: z21.string(),
+  summary: z21.string().min(1),
+  before: z21.unknown().optional(),
+  after: z21.unknown().optional()
+});
+var DefinitionDiff = z21.object({
+  kind: DefinitionKind,
+  key: DefinitionKey,
+  from: z21.number().int().positive(),
+  to: z21.number().int().positive(),
+  changes: z21.array(DiffChange),
+  /** Raw jsondiffpatch delta, for renderers that show the full tree. */
+  delta: z21.unknown()
+});
+var AuditExportFormat = z21.enum(["csv", "jsonl"]);
+var AuditFilter = z21.object({
+  /** Prefix match on the dotted action, e.g. `case.` or `case.note.added`. */
+  action: z21.string().min(1).max(200).optional(),
+  actorId: z21.string().min(1).optional(),
+  actorType: ActorType.optional(),
+  resourceType: z21.string().min(1).optional(),
+  resourceId: z21.string().min(1).optional(),
+  from: z21.coerce.date().optional(),
+  to: z21.coerce.date().optional()
+});
+
+// src/errors.ts
+var AletheiaError = class extends Error {
+  constructor(message, code, status = 500, details) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = new.target.name;
+  }
+  code;
+  status;
+  details;
+};
+var NotFoundError = class extends AletheiaError {
+  constructor(resource, id) {
+    super(`${resource} ${id} not found`, "not_found", 404);
+  }
+};
+var ValidationError = class extends AletheiaError {
+  constructor(message, details) {
+    super(message, "validation_error", 400, details);
+  }
+};
+var ConflictError = class extends AletheiaError {
+  constructor(message) {
+    super(message, "conflict", 409);
+  }
+};
+var NotImplementedError = class extends AletheiaError {
+  constructor(feature) {
+    super(`${feature} is not implemented yet`, "not_implemented", 501);
+  }
+};
+var TimeoutError = class extends AletheiaError {
+  constructor(operation, timeoutMs) {
+    super(`${operation} timed out after ${timeoutMs}ms`, "timeout", 504);
+  }
+};
+
+// src/ids.ts
+function createId() {
+  return globalThis.crypto.randomUUID();
+}
+
+// src/logger.ts
+var noopLogger = {
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0,
+  child: () => noopLogger
+};
+export {
+  Actor,
+  ActorType,
+  AddListEntriesInput,
+  AggregationPolicy,
+  AletheiaError,
+  ApprovalCommentInput,
+  ApprovalDecision,
+  ApprovalSettings,
+  AssignCaseInput,
+  AuditEvent,
+  AuditExportFormat,
+  AuditFilter,
+  Backtest,
+  BacktestProgress,
+  BacktestSample,
+  BacktestSampleFailure,
+  BacktestStatus,
+  BacktestSummary,
+  BaseEntity,
+  BranchStep,
+  CallPluginStep,
+  Case,
+  CaseFilter,
+  CaseNote,
+  CaseNoteInput,
+  CasePriority,
+  CaseQueue,
+  CaseSettings,
+  CaseSlaState,
+  CaseSort,
+  CaseStatus,
+  CaseView,
+  CloseCaseInput,
+  CollectionFlowBody,
+  CollectionFlowDefinition,
+  CollectionSubmission,
+  CollectionSubmitted,
+  Condition,
+  ConditionOp,
+  ConfigurePluginInput,
+  ConflictError,
+  CreateCaseStep,
+  CreateDocumentInput,
+  CreateSubjectInput,
+  CreateSubmissionInput,
+  DEFAULT_LINK_TTL_SECONDS,
+  DEFINITION_PATHS,
+  DEV_TENANT_ID,
+  DOCUMENT_CONTENT_TYPES,
+  DOCUMENT_MAX_BYTES,
+  DOCUMENT_OPEN_STATUSES,
+  DecideCaseInput,
+  Decision,
+  DecisionOutcome,
+  DecisionReason,
+  DecisionSource,
+  DefinitionApproval,
+  DefinitionDiff,
+  DefinitionIssue,
+  DefinitionKey,
+  DefinitionKind,
+  DefinitionStatus,
+  DefinitionVersionSummary,
+  DiffChange,
+  DiffOp,
+  DirectoryUser,
+  Document,
+  DocumentContentType,
+  DocumentDownload,
+  DocumentScan,
+  DocumentStatus,
+  DocumentUploadTicket,
+  EmitDecisionStep,
+  EvaluateRulesStep,
+  Event,
+  EventKey,
+  Field,
+  FieldOption,
+  FieldType,
+  FieldTypeDescription,
+  FieldValidation,
+  FileFieldValue,
+  FlowStep,
+  FormUiHints,
+  Id,
+  IngestEventsInput,
+  IngestEventsResult,
+  IssueSeverity,
+  JsonObject,
+  List,
+  ListEntry,
+  ListImportResult,
+  ListKind,
+  MAX_LINK_TTL_SECONDS,
+  ManualDecision,
+  NewEvent,
+  NewListEntry,
+  NotFoundError,
+  NotImplementedError,
+  OutcomeChange,
+  PluginCallback,
+  PluginCallbackSignal,
+  PluginCallbackStatus,
+  PluginDefinition,
+  PluginInvocation,
+  PluginInvocationStatus,
+  RemoveListEntriesInput,
+  RuleDefinition,
+  RuleEvaluation,
+  RuleEvaluationResult,
+  RuleOutcome,
+  RuleSetBody,
+  RuleSetDefinition,
+  RuleSetRule,
+  RuleSetUseCase,
+  RuleSeverity,
+  RuleType,
+  RunDefinitionInput,
+  SYSTEM_ACTOR,
+  SaveSubmissionInput,
+  ScoreBand,
+  ScoreClamp,
+  SortOrder,
+  StartBacktestInput,
+  StartWorkflowRunInput,
+  StepTypeDescription,
+  Subject,
+  SubjectKind,
+  SubjectListQuery,
+  SubjectStatus,
+  SubmissionStatus,
+  Tenant,
+  TenantContext,
+  TenantSettings,
+  TimelineEntry,
+  TimelineKind,
+  TimelineQuery,
+  TimeoutError,
+  Timestamps,
+  UpsertCaseQueueInput,
+  UpsertCollectionFlowInput,
+  UpsertListInput,
+  UpsertRuleDefinitionInput,
+  UpsertRuleSetInput,
+  UpsertWorkflowDefinitionInput,
+  ValidationError,
+  ValidationReport,
+  WaitForCollectionStep,
+  WebOrigin,
+  WebhookEventRecord,
+  WorkflowDefinition,
+  WorkflowDefinitionBody,
+  WorkflowRun,
+  WorkflowRunStatus,
+  WorkflowStep,
+  WorkflowTrigger,
+  WorkflowUi,
+  bandFor,
+  caseSlaState,
+  createId,
+  evaluateCondition,
+  getPath,
+  noopLogger,
+  normalizeListValue,
+  stepTargets,
+  systemContext,
+  temporalWorkflowId
+};
+//# sourceMappingURL=index.js.map