@aletheia-dev/api-client 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @aletheia-dev/api-client
 
+## 0.2.0
+
+### Minor Changes
+
+- [#10](https://github.com/akhiljames/aletheia/pull/10) [`2d95c87`](https://github.com/akhiljames/aletheia/commit/2d95c8708f7119e066d9cfdf91dbb753e15923f1) Thanks [@akhiljames](https://github.com/akhiljames)! - New `policyPacks` domain: `import(pack, { publish? })` posts a `PolicyPack` to
+  `POST /definitions/import` and `export(keys, { name?, version?, description? })` reads one back
+  from `GET /definitions/export`. `PolicyPack` and the import result schema are re-exported.
+
+### Patch Changes
+
+- Updated dependencies [[`1b1c13f`](https://github.com/akhiljames/aletheia/commit/1b1c13f230b10d8d4704196b510edc164d14e7e9)]:
+  - @aletheia-dev/core@0.2.0
+
 ## 0.1.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -20,117 +20,121 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  ActorType: () => import_core9.ActorType,
-  AddListEntriesInput: () => import_core13.AddListEntriesInput,
-  AggregationPolicy: () => import_core13.AggregationPolicy,
+  ActorType: () => import_core10.ActorType,
+  AddListEntriesInput: () => import_core15.AddListEntriesInput,
+  AggregationPolicy: () => import_core15.AggregationPolicy,
   ApiError: () => ApiError,
-  ApprovalCommentInput: () => import_core9.ApprovalCommentInput,
-  ApprovalDecision: () => import_core9.ApprovalDecision,
+  ApprovalCommentInput: () => import_core10.ApprovalCommentInput,
+  ApprovalDecision: () => import_core10.ApprovalDecision,
   ApprovalOutcome: () => ApprovalOutcome,
-  AssignCaseInput: () => import_core11.AssignCaseInput,
-  AuditEvent: () => import_core9.AuditEvent,
-  AuditExportFormat: () => import_core9.AuditExportFormat,
-  AuditFilter: () => import_core9.AuditFilter,
-  Backtest: () => import_core13.Backtest,
-  BacktestProgress: () => import_core13.BacktestProgress,
-  BacktestSample: () => import_core13.BacktestSample,
-  BacktestSampleFailure: () => import_core13.BacktestSampleFailure,
-  BacktestStatus: () => import_core13.BacktestStatus,
-  BacktestSummary: () => import_core13.BacktestSummary,
-  Case: () => import_core11.Case,
+  AssignCaseInput: () => import_core13.AssignCaseInput,
+  AuditEvent: () => import_core10.AuditEvent,
+  AuditExportFormat: () => import_core10.AuditExportFormat,
+  AuditFilter: () => import_core10.AuditFilter,
+  Backtest: () => import_core15.Backtest,
+  BacktestProgress: () => import_core15.BacktestProgress,
+  BacktestSample: () => import_core15.BacktestSample,
+  BacktestSampleFailure: () => import_core15.BacktestSampleFailure,
+  BacktestStatus: () => import_core15.BacktestStatus,
+  BacktestSummary: () => import_core15.BacktestSummary,
+  Case: () => import_core13.Case,
   CaseDetail: () => CaseDetail,
-  CaseFilter: () => import_core11.CaseFilter,
-  CaseNote: () => import_core11.CaseNote,
-  CaseNoteInput: () => import_core11.CaseNoteInput,
-  CasePriority: () => import_core11.CasePriority,
-  CaseQueue: () => import_core11.CaseQueue,
+  CaseFilter: () => import_core13.CaseFilter,
+  CaseNote: () => import_core13.CaseNote,
+  CaseNoteInput: () => import_core13.CaseNoteInput,
+  CasePriority: () => import_core13.CasePriority,
+  CaseQueue: () => import_core13.CaseQueue,
   CaseQueueCount: () => CaseQueueCount,
-  CaseSlaState: () => import_core11.CaseSlaState,
-  CaseSort: () => import_core11.CaseSort,
-  CaseStatus: () => import_core11.CaseStatus,
-  CaseView: () => import_core11.CaseView,
-  CloseCaseInput: () => import_core11.CloseCaseInput,
-  Condition: () => import_core10.Condition,
-  ConditionOp: () => import_core10.ConditionOp,
-  CreateDocumentInput: () => import_core12.CreateDocumentInput,
+  CaseSlaState: () => import_core13.CaseSlaState,
+  CaseSort: () => import_core13.CaseSort,
+  CaseStatus: () => import_core13.CaseStatus,
+  CaseView: () => import_core13.CaseView,
+  CloseCaseInput: () => import_core13.CloseCaseInput,
+  Condition: () => import_core12.Condition,
+  ConditionOp: () => import_core12.ConditionOp,
+  CreateDocumentInput: () => import_core14.CreateDocumentInput,
   CreatedSubmission: () => CreatedSubmission,
-  DEFINITION_PATHS: () => import_core9.DEFINITION_PATHS,
-  DOCUMENT_CONTENT_TYPES: () => import_core12.DOCUMENT_CONTENT_TYPES,
-  DOCUMENT_MAX_BYTES: () => import_core12.DOCUMENT_MAX_BYTES,
-  DOCUMENT_OPEN_STATUSES: () => import_core12.DOCUMENT_OPEN_STATUSES,
+  DEFINITION_PATHS: () => import_core10.DEFINITION_PATHS,
+  DOCUMENT_CONTENT_TYPES: () => import_core14.DOCUMENT_CONTENT_TYPES,
+  DOCUMENT_MAX_BYTES: () => import_core14.DOCUMENT_MAX_BYTES,
+  DOCUMENT_OPEN_STATUSES: () => import_core14.DOCUMENT_OPEN_STATUSES,
   DecideCaseResult: () => DecideCaseResult,
-  DefinitionApproval: () => import_core9.DefinitionApproval,
-  DefinitionDiff: () => import_core9.DefinitionDiff,
-  DefinitionIssue: () => import_core10.DefinitionIssue,
-  DefinitionKind: () => import_core9.DefinitionKind,
-  DefinitionVersionSummary: () => import_core9.DefinitionVersionSummary,
-  DiffChange: () => import_core9.DiffChange,
-  DiffOp: () => import_core9.DiffOp,
-  DirectoryUser: () => import_core11.DirectoryUser,
-  Document: () => import_core12.Document,
-  DocumentContentType: () => import_core12.DocumentContentType,
-  DocumentDownload: () => import_core12.DocumentDownload,
+  DefinitionApproval: () => import_core10.DefinitionApproval,
+  DefinitionDiff: () => import_core10.DefinitionDiff,
+  DefinitionIssue: () => import_core12.DefinitionIssue,
+  DefinitionKind: () => import_core10.DefinitionKind,
+  DefinitionVersionSummary: () => import_core10.DefinitionVersionSummary,
+  DiffChange: () => import_core10.DiffChange,
+  DiffOp: () => import_core10.DiffOp,
+  DirectoryUser: () => import_core13.DirectoryUser,
+  Document: () => import_core14.Document,
+  DocumentContentType: () => import_core14.DocumentContentType,
+  DocumentDownload: () => import_core14.DocumentDownload,
   DocumentPollTimeoutError: () => DocumentPollTimeoutError,
-  DocumentScan: () => import_core12.DocumentScan,
-  DocumentStatus: () => import_core12.DocumentStatus,
-  DocumentUploadTicket: () => import_core12.DocumentUploadTicket,
+  DocumentScan: () => import_core14.DocumentScan,
+  DocumentStatus: () => import_core14.DocumentStatus,
+  DocumentUploadTicket: () => import_core14.DocumentUploadTicket,
   DryRunResult: () => DryRunResult,
-  Event: () => import_core13.Event,
-  EventKey: () => import_core13.EventKey,
+  Event: () => import_core15.Event,
+  EventKey: () => import_core15.EventKey,
   FORBIDDEN_CODES: () => FORBIDDEN_CODES,
-  FieldTypeDescription: () => import_core10.FieldTypeDescription,
-  FileFieldValue: () => import_core12.FileFieldValue,
-  FormUiHints: () => import_core10.FormUiHints,
+  FieldTypeDescription: () => import_core12.FieldTypeDescription,
+  FileFieldValue: () => import_core14.FileFieldValue,
+  FormUiHints: () => import_core12.FormUiHints,
   HealthStatus: () => HealthStatus,
-  IngestEventsInput: () => import_core13.IngestEventsInput,
-  IngestEventsResult: () => import_core13.IngestEventsResult,
-  IssueSeverity: () => import_core10.IssueSeverity,
-  List: () => import_core13.List,
-  ListEntry: () => import_core13.ListEntry,
-  ListImportResult: () => import_core13.ListImportResult,
-  ListKind: () => import_core13.ListKind,
+  IngestEventsInput: () => import_core15.IngestEventsInput,
+  IngestEventsResult: () => import_core15.IngestEventsResult,
+  IssueSeverity: () => import_core12.IssueSeverity,
+  List: () => import_core15.List,
+  ListEntry: () => import_core15.ListEntry,
+  ListImportResult: () => import_core15.ListImportResult,
+  ListKind: () => import_core15.ListKind,
   Me: () => Me,
   MePrincipal: () => MePrincipal,
-  NewEvent: () => import_core13.NewEvent,
-  NewListEntry: () => import_core13.NewListEntry,
+  NewEvent: () => import_core15.NewEvent,
+  NewListEntry: () => import_core15.NewListEntry,
+  POLICY_PACK_MAX_LIST_ROWS: () => import_core11.POLICY_PACK_MAX_LIST_ROWS,
   PluginSummary: () => PluginSummary,
+  PolicyPack: () => import_core11.PolicyPack,
+  PolicyPackImportResult: () => import_core11.PolicyPackImportResult,
+  PolicyPackKeyRef: () => import_core11.PolicyPackKeyRef,
   RUNTIME_CONFIG_PATH: () => RUNTIME_CONFIG_PATH,
   ReadyStatus: () => ReadyStatus,
-  RemoveListEntriesInput: () => import_core13.RemoveListEntriesInput,
+  RemoveListEntriesInput: () => import_core15.RemoveListEntriesInput,
   RemovedCount: () => RemovedCount,
-  RuleSetBody: () => import_core13.RuleSetBody,
-  RuleSetDefinition: () => import_core13.RuleSetDefinition,
-  RuleSetRule: () => import_core13.RuleSetRule,
-  RuleSetUseCase: () => import_core13.RuleSetUseCase,
+  RuleSetBody: () => import_core15.RuleSetBody,
+  RuleSetDefinition: () => import_core15.RuleSetDefinition,
+  RuleSetRule: () => import_core15.RuleSetRule,
+  RuleSetUseCase: () => import_core15.RuleSetUseCase,
   RuleTypeDescription: () => RuleTypeDescription,
   RuleUiHints: () => RuleUiHints,
   RuntimeConfig: () => RuntimeConfig,
-  ScoreBand: () => import_core13.ScoreBand,
-  ScoreClamp: () => import_core13.ScoreClamp,
-  SortOrder: () => import_core11.SortOrder,
-  StartBacktestInput: () => import_core13.StartBacktestInput,
-  StepTypeDescription: () => import_core10.StepTypeDescription,
-  Subject: () => import_core15.Subject,
-  SubjectKind: () => import_core15.SubjectKind,
-  SubjectListQuery: () => import_core15.SubjectListQuery,
-  SubjectStatus: () => import_core15.SubjectStatus,
+  ScoreBand: () => import_core15.ScoreBand,
+  ScoreClamp: () => import_core15.ScoreClamp,
+  SortOrder: () => import_core13.SortOrder,
+  StartBacktestInput: () => import_core15.StartBacktestInput,
+  StepTypeDescription: () => import_core12.StepTypeDescription,
+  Subject: () => import_core17.Subject,
+  SubjectKind: () => import_core17.SubjectKind,
+  SubjectListQuery: () => import_core17.SubjectListQuery,
+  SubjectStatus: () => import_core17.SubjectStatus,
   SubmissionDetail: () => SubmissionDetail,
   SubmissionEmbed: () => SubmissionEmbed,
   SubmissionStatus: () => SubmissionStatus,
-  TenantSettings: () => import_core14.TenantSettings,
-  TimelineEntry: () => import_core15.TimelineEntry,
-  TimelineKind: () => import_core15.TimelineKind,
-  TimelineQuery: () => import_core15.TimelineQuery,
+  TenantSettings: () => import_core16.TenantSettings,
+  TimelineEntry: () => import_core17.TimelineEntry,
+  TimelineKind: () => import_core17.TimelineKind,
+  TimelineQuery: () => import_core17.TimelineQuery,
   UploadError: () => UploadError,
-  UpsertCaseQueueInput: () => import_core11.UpsertCaseQueueInput,
-  UpsertListInput: () => import_core13.UpsertListInput,
-  UpsertRuleSetInput: () => import_core13.UpsertRuleSetInput,
-  ValidationReport: () => import_core10.ValidationReport,
-  WebOrigin: () => import_core14.WebOrigin,
+  UpsertCaseQueueInput: () => import_core13.UpsertCaseQueueInput,
+  UpsertListInput: () => import_core15.UpsertListInput,
+  UpsertRuleSetInput: () => import_core15.UpsertRuleSetInput,
+  ValidationReport: () => import_core12.ValidationReport,
+  WebOrigin: () => import_core16.WebOrigin,
   auditFilterParams: () => auditFilterParams,
-  bandFor: () => import_core13.bandFor,
+  bandFor: () => import_core15.bandFor,
   caseListParams: () => caseListParams,
-  caseSlaState: () => import_core11.caseSlaState,
+  caseSlaState: () => import_core13.caseSlaState,
   checkFileBeforeUpload: () => checkFileBeforeUpload,
   createApiClient: () => createApiClient,
   isApiError: () => isApiError,
@@ -140,7 +144,9 @@ __export(src_exports, {
   isTerminalDocumentStatus: () => isTerminalDocumentStatus,
   isUnauthenticated: () => isUnauthenticated,
   loadRuntimeConfig: () => loadRuntimeConfig,
-  normalizeListValue: () => import_core13.normalizeListValue,
+  normalizeListValue: () => import_core15.normalizeListValue,
+  parsePolicyPackKeyRef: () => import_core11.parsePolicyPackKeyRef,
+  policyPackKeyRefs: () => import_core11.policyPackKeyRefs,
   pollDocument: () => pollDocument,
   resolveConfig: () => resolveConfig,
   uploadToStorage: () => uploadToStorage,
@@ -380,8 +386,9 @@ function governanceDomain(http) {
 }
 
 // src/index.ts
-var import_core9 = require("@aletheia-dev/core");
 var import_core10 = require("@aletheia-dev/core");
+var import_core11 = require("@aletheia-dev/core");
+var import_core12 = require("@aletheia-dev/core");
 
 // src/cases.ts
 var import_core3 = require("@aletheia-dev/core");
@@ -469,7 +476,7 @@ function usersDomain(http) {
 }
 
 // src/index.ts
-var import_core11 = require("@aletheia-dev/core");
+var import_core13 = require("@aletheia-dev/core");
 
 // src/documents.ts
 var import_core4 = require("@aletheia-dev/core");
@@ -603,14 +610,14 @@ async function pollDocument(client, id, opts = {}) {
 }
 
 // src/index.ts
-var import_core12 = require("@aletheia-dev/core");
-var import_core13 = require("@aletheia-dev/core");
 var import_core14 = require("@aletheia-dev/core");
 var import_core15 = require("@aletheia-dev/core");
+var import_core16 = require("@aletheia-dev/core");
+var import_core17 = require("@aletheia-dev/core");
 
 // src/client.ts
 var import_zod7 = require("zod");
-var import_core8 = require("@aletheia-dev/core");
+var import_core9 = require("@aletheia-dev/core");
 
 // src/builder.ts
 var import_core5 = require("@aletheia-dev/core");
@@ -626,23 +633,44 @@ function validateCall(http, path) {
   return (body) => http.parsed(import_core5.ValidationReport, `${path}/validate`, { method: "POST", body });
 }
 
-// src/tenants.ts
+// src/definitions-packs.ts
 var import_core6 = require("@aletheia-dev/core");
+var keyRef = (key) => typeof key === "string" ? key : `${key.kind}:${key.key}`;
+function policyPacksDomain(http) {
+  return {
+    import: (pack, options = {}) => http.parsed(import_core6.PolicyPackImportResult, "/definitions/import", {
+      method: "POST",
+      body: pack,
+      query: { publish: options.publish ? "true" : void 0 }
+    }),
+    export: (keys, options = {}) => http.parsed(import_core6.PolicyPack, "/definitions/export", {
+      query: {
+        keys: keys.map(keyRef),
+        name: options.name,
+        version: options.version,
+        description: options.description
+      }
+    })
+  };
+}
+
+// src/tenants.ts
+var import_core7 = require("@aletheia-dev/core");
 function tenantsDomain(http) {
   return {
-    getSettings: () => http.parsed(import_core6.TenantSettings, "/tenants/me/settings"),
-    updateSettings: (body) => http.parsed(import_core6.TenantSettings, "/tenants/me/settings", { method: "PUT", body })
+    getSettings: () => http.parsed(import_core7.TenantSettings, "/tenants/me/settings"),
+    updateSettings: (body) => http.parsed(import_core7.TenantSettings, "/tenants/me/settings", { method: "PUT", body })
   };
 }
 
 // src/workflow-runs.ts
-var import_core7 = require("@aletheia-dev/core");
+var import_core8 = require("@aletheia-dev/core");
 var import_zod6 = require("zod");
-var RunList = import_zod6.z.object({ items: import_zod6.z.array(import_core7.WorkflowRun) });
+var RunList = import_zod6.z.object({ items: import_zod6.z.array(import_core8.WorkflowRun) });
 function workflowRunsDomain(http) {
   return {
-    start: (body) => http.parsed(import_core7.WorkflowRun, "/workflow-runs", { method: "POST", body }),
-    get: (id) => http.parsed(import_core7.WorkflowRun, `/workflow-runs/${encodeSegment(id)}`),
+    start: (body) => http.parsed(import_core8.WorkflowRun, "/workflow-runs", { method: "POST", body }),
+    get: (id) => http.parsed(import_core8.WorkflowRun, `/workflow-runs/${encodeSegment(id)}`),
     listBySubject: async (subjectId) => (await http.parsed(RunList, "/workflow-runs", { query: { subjectId } })).items,
     history: (id) => http.request(`/workflow-runs/${encodeSegment(id)}/history`)
   };
@@ -685,7 +713,7 @@ var RuleUiHints = import_zod7.z.object({
   listPicker: import_zod7.z.array(import_zod7.z.string()).optional()
 });
 var RuleTypeDescription = import_zod7.z.object({
-  type: import_core8.RuleType,
+  type: import_core9.RuleType,
   description: import_zod7.z.string(),
   /** JSON Schema of the rule config, produced by `z.toJSONSchema` on the API. */
   configSchema: import_zod7.z.unknown(),
@@ -694,36 +722,36 @@ var RuleTypeDescription = import_zod7.z.object({
   uiHints: RuleUiHints.optional()
 });
 var DryRunResult = import_zod7.z.object({
-  result: import_core8.RuleEvaluationResult,
+  result: import_core9.RuleEvaluationResult,
   rule: import_zod7.z.object({
     key: import_zod7.z.string(),
     version: import_zod7.z.number().int(),
-    status: import_core8.DefinitionStatus,
-    type: import_core8.RuleType
+    status: import_core9.DefinitionStatus,
+    type: import_core9.RuleType
   }),
   /** Data namespaces the rule may reference, a hint for composing inline test data. */
   dataPaths: import_zod7.z.array(import_zod7.z.string()).default([])
 });
 var RemovedCount = import_zod7.z.object({ removed: import_zod7.z.number().int().nonnegative() });
 var SubmissionDetail = import_zod7.z.object({
-  submission: import_core8.CollectionSubmission,
-  flow: import_core8.CollectionFlowDefinition
+  submission: import_core9.CollectionSubmission,
+  flow: import_core9.CollectionFlowDefinition
 });
 var SubmissionStatus = import_zod7.z.object({
   submission: import_zod7.z.object({
-    id: import_core8.Id,
-    status: import_core8.SubmissionStatus,
+    id: import_core9.Id,
+    status: import_core9.SubmissionStatus,
     submittedAt: import_zod7.z.coerce.date().nullable()
   }),
   run: import_zod7.z.object({
-    id: import_core8.Id,
-    status: import_core8.WorkflowRunStatus,
+    id: import_core9.Id,
+    status: import_core9.WorkflowRunStatus,
     currentStepId: import_zod7.z.string().nullable(),
-    decision: import_zod7.z.object({ outcome: import_core8.DecisionOutcome }).nullable()
+    decision: import_zod7.z.object({ outcome: import_core9.DecisionOutcome }).nullable()
   }).nullable()
 });
 var CreatedSubmission = import_zod7.z.object({
-  submission: import_core8.CollectionSubmission,
+  submission: import_core9.CollectionSubmission,
   link: import_zod7.z.string().nullable()
 });
 var SubmissionEmbed = import_zod7.z.object({
@@ -767,18 +795,18 @@ function createApiClient(options) {
     /** The caller's principal, tenant and permissions as the API sees the bearer token. */
     me: () => http.parsed(Me, "/me"),
     subjects: {
-      create: (body) => http.parsed(import_core8.Subject, "/subjects", { method: "POST", body }),
+      create: (body) => http.parsed(import_core9.Subject, "/subjects", { method: "POST", body }),
       /**
        * Subjects matching `query`: `search` matches the external id and `data.name` /
        * `data.legalName`; `riskScoreMin`/`riskScoreMax` bound the risk score (`subjects:read`).
        */
-      list: (query = {}) => list(import_core8.Subject, "/subjects", query),
-      get: (id) => http.parsed(import_core8.Subject, `/subjects/${encodeSegment(id)}`),
+      list: (query = {}) => list(import_core9.Subject, "/subjects", query),
+      get: (id) => http.parsed(import_core9.Subject, `/subjects/${encodeSegment(id)}`),
       /**
        * 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, query = {}) => list(import_core8.TimelineEntry, `/subjects/${encodeSegment(id)}/timeline`, timelineParams(query))
+      timeline: (id, query = {}) => list(import_core9.TimelineEntry, `/subjects/${encodeSegment(id)}/timeline`, timelineParams(query))
     },
     workflowRuns: workflowRunsDomain(http),
     /** Review cases: filtered lists, detail, decide, assign/claim/close and notes. See `cases.ts`. */
@@ -789,7 +817,7 @@ function createApiClient(options) {
     users: usersDomain(http),
     workflowDefinitions: {
       ...definitions(
-        import_core8.WorkflowDefinition,
+        import_core9.WorkflowDefinition,
         "/workflow-definitions"
       ),
       /** Validates a draft body without saving; issues carry step ids. */
@@ -799,7 +827,7 @@ function createApiClient(options) {
     builder: builderDomain(http),
     ruleDefinitions: {
       ...definitions(
-        import_core8.RuleDefinition,
+        import_core9.RuleDefinition,
         "/rule-definitions"
       ),
       /** Evaluates one rule version against a subject or inline data; nothing is recorded. */
@@ -811,14 +839,16 @@ function createApiClient(options) {
     ruleTypes: {
       list: () => list(RuleTypeDescription, "/rule-types")
     },
+    /** Import and export sets of definitions as policy packs. See `definitions-packs.ts`. */
+    policyPacks: policyPacksDomain(http),
     /** Versioned, ordered groups of rules with an aggregation policy (`/rule-sets`). */
     ruleSets: definitions(
-      import_core8.RuleSetDefinition,
+      import_core9.RuleSetDefinition,
       "/rule-sets"
     ),
     collectionFlows: {
       ...definitions(
-        import_core8.CollectionFlowDefinition,
+        import_core9.CollectionFlowDefinition,
         "/collection-flows"
       ),
       /** Validates a draft flow body without saving; issues carry step / field keys. */
@@ -828,11 +858,11 @@ function createApiClient(options) {
       /** Creates the submission and returns the applicant link alongside it. */
       create: (body) => http.parsed(CreatedSubmission, "/collection-submissions", { method: "POST", body }),
       get: (id) => http.parsed(SubmissionDetail, `/collection-submissions/${encodeSegment(id)}`),
-      save: (id, body) => http.parsed(import_core8.CollectionSubmission, `/collection-submissions/${encodeSegment(id)}`, {
+      save: (id, body) => http.parsed(import_core9.CollectionSubmission, `/collection-submissions/${encodeSegment(id)}`, {
         method: "PATCH",
         body
       }),
-      submit: (id) => http.parsed(import_core8.CollectionSubmission, `/collection-submissions/${encodeSegment(id)}/submit`, {
+      submit: (id) => http.parsed(import_core9.CollectionSubmission, `/collection-submissions/${encodeSegment(id)}/submit`, {
         method: "POST"
       }),
       /** Where the submission's workflow run is; readable with the applicant's token. */
@@ -843,22 +873,22 @@ function createApiClient(options) {
     /** Subject events: the facts velocity rules aggregate over. */
     events: {
       /** Inserts events; re-sent idempotency keys are counted as `duplicates`, not errors. */
-      ingest: (body) => http.parsed(import_core8.IngestEventsResult, "/events", { method: "POST", body }),
+      ingest: (body) => http.parsed(import_core9.IngestEventsResult, "/events", { method: "POST", body }),
       /** Newest first. */
-      list: (query = {}) => list(import_core8.Event, "/events", { ...query, from: isoOf3(query.from), to: isoOf3(query.to) })
+      list: (query = {}) => list(import_core9.Event, "/events", { ...query, from: isoOf3(query.from), to: isoOf3(query.to) })
     },
     /**
      * 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) => http.parsed(import_core8.Backtest, "/backtests", { method: "POST", body }),
+      start: (body) => http.parsed(import_core9.Backtest, "/backtests", { method: "POST", body }),
       /** Newest first. */
-      list: (query = {}) => list(import_core8.Backtest, "/backtests", query),
-      get: (id) => http.parsed(import_core8.Backtest, `/backtests/${encodeSegment(id)}`)
+      list: (query = {}) => list(import_core9.Backtest, "/backtests", query),
+      get: (id) => http.parsed(import_core9.Backtest, `/backtests/${encodeSegment(id)}`)
     },
     decisions: {
-      listBySubject: (subjectId) => list(import_core8.Decision, "/decisions", { subjectId })
+      listBySubject: (subjectId) => list(import_core9.Decision, "/decisions", { subjectId })
     },
     /** Filtered audit trail, exports and manifest verification (`audit:read`). See `audit.ts`. */
     audit,
@@ -869,12 +899,12 @@ function createApiClient(options) {
     /** Version history, diffs and the approval workflow of definitions. See `governance.ts`. */
     governance: governanceDomain(http),
     plugins: {
-      list: () => list(import_core8.PluginDefinition, "/plugins"),
+      list: () => list(import_core9.PluginDefinition, "/plugins"),
       available: () => list(PluginSummary, "/plugins/available"),
-      configure: (name, body) => http.parsed(import_core8.PluginDefinition, `/plugins/${encodeSegment(name)}`, { method: "PUT", body })
+      configure: (name, body) => http.parsed(import_core9.PluginDefinition, `/plugins/${encodeSegment(name)}`, { method: "PUT", body })
     },
     pluginInvocations: {
-      list: (query = {}) => list(import_core8.PluginInvocation, "/plugin-invocations", query)
+      list: (query = {}) => list(import_core9.PluginInvocation, "/plugin-invocations", query)
     },
     /**
      * Uploaded files: `create` -> `uploadToStorage` (helper) -> `finalize` -> `pollDocument`
@@ -885,15 +915,15 @@ function createApiClient(options) {
     tenants: tenantsDomain(http),
     /** Tenant lists (blocklists / allowlists) and their entries. Lists are keyed, not versioned. */
     lists: {
-      list: () => list(import_core8.List, "/lists"),
-      get: (key) => http.parsed(import_core8.List, `/lists/${encodeSegment(key)}`),
+      list: () => list(import_core9.List, "/lists"),
+      get: (key) => http.parsed(import_core9.List, `/lists/${encodeSegment(key)}`),
       /** Creates the list or updates its metadata; entries are untouched. */
-      upsert: (key, body) => http.parsed(import_core8.List, `/lists/${encodeSegment(key)}`, { method: "PUT", body }),
+      upsert: (key, body) => http.parsed(import_core9.List, `/lists/${encodeSegment(key)}`, { method: "PUT", body }),
       remove: async (key) => {
         await http.request(`/lists/${encodeSegment(key)}`, { method: "DELETE" });
       },
-      entries: (key, query = {}) => list(import_core8.ListEntry, `/lists/${encodeSegment(key)}/entries`, query),
-      addEntries: (key, body) => http.parsed(import_core8.ListImportResult, `/lists/${encodeSegment(key)}/entries`, {
+      entries: (key, query = {}) => list(import_core9.ListEntry, `/lists/${encodeSegment(key)}/entries`, query),
+      addEntries: (key, body) => http.parsed(import_core9.ListImportResult, `/lists/${encodeSegment(key)}/entries`, {
         method: "POST",
         body
       }),
@@ -902,7 +932,7 @@ function createApiClient(options) {
         body
       }),
       /** Uploads a CSV (one value per line, optional `value,reason,expires_at` header). */
-      importCsv: (key, csv) => http.parsed(import_core8.ListImportResult, `/lists/${encodeSegment(key)}/import`, {
+      importCsv: (key, csv) => http.parsed(import_core9.ListImportResult, `/lists/${encodeSegment(key)}/import`, {
         method: "POST",
         raw: { content: csv, contentType: "text/csv" }
       })