@wildo-ai/saas-models 1.1.4 → 1.1.6

package/dist/esm/http-api-binding/read-through-engine-anchors.shared.js

@@ -0,0 +1,42 @@
+/**
+ * The two fields the ENGINE puts on a read-through row, which nothing remote supplies.
+ *
+ * A VIRTUAL resource's schema describes the REMOTE entity: every field in it comes from the target,
+ * and there is no local row to carry anything of ours. But two facts have to travel with each row
+ * anyway, because the engine's own gates read them:
+ *
+ *  - the OWNER organization, which the per-row tenant gate compares against the caller's (#1055 §6);
+ *  - the ORGANIZATION UNIT owning the row's remote PARTITION, which organization-unit narrowing
+ *    filters on (#1058 §3).
+ *
+ * Both are read from the field-identifier map rather than written out, because that is what each
+ * value IS — the row points at an organization and at a unit, so the fields are those resources'
+ * foreign-key spellings. Named here, in one module, because they are written and read in places
+ * that are far apart and must agree: the HTTP_API projector STAMPS them per row, the resource
+ * factory DECLARES them on the schema, and the resources registry names the second one as a
+ * read-through resource's derived `unitFieldName`. A literal in any one of those is a second
+ * declaration of a name the others must match — and the failure is silent, because a narrowing
+ * declaration naming a field the projector does not write confines every caller to nothing.
+ */
+import { CoreResourceType, coreResourceShared_FieldIdentifier } from '../resources/resources.shared.core.definitions.js';
+/** The field the engine's per-row tenant gate reads on a projected row. */
+export const HTTP_API_TENANT_ANCHOR_FIELD = coreResourceShared_FieldIdentifier[CoreResourceType.ORGANIZATIONS];
+/**
+ * The field a READ-THROUGH resource is narrowed on (#1058 R7).
+ *
+ * The same name the resources registry DERIVES as `unitFieldName` for any resource bound to a
+ * partitioned system of record, and the same name the projector stamps.
+ */
+export const READ_THROUGH_ORGANIZATION_UNIT_FIELD_NAME = coreResourceShared_FieldIdentifier[CoreResourceType.ORGANIZATION_UNITS];
+/**
+ * Both, as the resource factory walks them — the injection, the reserved-name collision check, and
+ * the binding-target refusals all run over this one list.
+ *
+ * A list rather than three separate checks per field, so that a third anchor added tomorrow is
+ * guarded by every rule that guards these two rather than by whichever ones somebody remembers.
+ */
+export const HTTP_API_ENGINE_INJECTED_FIELDS = [
+    HTTP_API_TENANT_ANCHOR_FIELD,
+    READ_THROUGH_ORGANIZATION_UNIT_FIELD_NAME,
+];
+//# sourceMappingURL=read-through-engine-anchors.shared.js.map

package/dist/esm/http-api-binding/read-through-engine-anchors.shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-through-engine-anchors.shared.js","sourceRoot":"","sources":["../../../../src/http-api-binding/read-through-engine-anchors.shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,kCAAkC,EAAE,MAAM,gDAAgD,CAAC;AAEtH,2EAA2E;AAC3E,MAAM,CAAC,MAAM,4BAA4B,GACvC,kCAAkC,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;AAErE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yCAAyC,GACpD,kCAAkC,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,CAAC;AAE1E;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAsB;IAChE,4BAA4B;IAC5B,yCAAyC;CAC1C,CAAC","sourcesContent":["/**\n * The two fields the ENGINE puts on a read-through row, which nothing remote supplies.\n *\n * A VIRTUAL resource's schema describes the REMOTE entity: every field in it comes from the target,\n * and there is no local row to carry anything of ours. But two facts have to travel with each row\n * anyway, because the engine's own gates read them:\n *\n *  - the OWNER organization, which the per-row tenant gate compares against the caller's (#1055 §6);\n *  - the ORGANIZATION UNIT owning the row's remote PARTITION, which organization-unit narrowing\n *    filters on (#1058 §3).\n *\n * Both are read from the field-identifier map rather than written out, because that is what each\n * value IS — the row points at an organization and at a unit, so the fields are those resources'\n * foreign-key spellings. Named here, in one module, because they are written and read in places\n * that are far apart and must agree: the HTTP_API projector STAMPS them per row, the resource\n * factory DECLARES them on the schema, and the resources registry names the second one as a\n * read-through resource's derived `unitFieldName`. A literal in any one of those is a second\n * declaration of a name the others must match — and the failure is silent, because a narrowing\n * declaration naming a field the projector does not write confines every caller to nothing.\n */\n\nimport { CoreResourceType, coreResourceShared_FieldIdentifier } from '../resources/resources.shared.core.definitions';\n\n/** The field the engine's per-row tenant gate reads on a projected row. */\nexport const HTTP_API_TENANT_ANCHOR_FIELD: string =\n  coreResourceShared_FieldIdentifier[CoreResourceType.ORGANIZATIONS];\n\n/**\n * The field a READ-THROUGH resource is narrowed on (#1058 R7).\n *\n * The same name the resources registry DERIVES as `unitFieldName` for any resource bound to a\n * partitioned system of record, and the same name the projector stamps.\n */\nexport const READ_THROUGH_ORGANIZATION_UNIT_FIELD_NAME: string =\n  coreResourceShared_FieldIdentifier[CoreResourceType.ORGANIZATION_UNITS];\n\n/**\n * Both, as the resource factory walks them — the injection, the reserved-name collision check, and\n * the binding-target refusals all run over this one list.\n *\n * A list rather than three separate checks per field, so that a third anchor added tomorrow is\n * guarded by every rule that guards these two rather than by whichever ones somebody remembers.\n */\nexport const HTTP_API_ENGINE_INJECTED_FIELDS: readonly string[] = [\n  HTTP_API_TENANT_ANCHOR_FIELD,\n  READ_THROUGH_ORGANIZATION_UNIT_FIELD_NAME,\n];\n"]}

package/dist/esm/i18n/application-config-vocabulary.shared.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The vocabularies whose NAME the framework owns and whose VALUES an application declares. "Config" is meant broadly:
+ * an application's declarations, in its configuration (`agentWorkReview.reasonCodes`, `organizationTypes`) or in what
+ * its backend modules register (a gate's `pauseStates`, #1864).
+ *
+ * The labelling planner reads each one's values where the application declares them — the configuration, or the
+ * backend introspection for a gate's pause states — and words them under `system_enums.<name>.<value>`, and a surface
+ * that shows one of the values reads the same key. So a value the application declares is worded the moment it is
+ * declared, and one it removes stops being planned, with no list of the application's values kept anywhere.
+ *
+ * The engine's own open vocabularies, whose values the ENGINE declares, are `EngineOpenVocabulary`.
+ *
+ * Kept in its own file with no imports, so a schema can name its vocabulary without importing anything else.
+ */
+export declare enum ApplicationConfigVocabulary {
+    /** The reasons an expert may give for correcting an agent's work (`agentWorkReview.reasonCodes`, #1921). */
+    AGENT_WORK_REASON_CODE = "AgentWorkReasonCode",
+    /** The organization types an application declares (`organizationTypes`, keyed by type): an organization's `type` (#1851). */
+    ORGANIZATION_TYPE = "OrganizationType",
+    /**
+     * Why a reviewer may stop a decision's clocks: the pause states every approval gate declares
+     * (`humanApproval.deadlines.pauseStates` on a function tool, #1864). The approval inbox's Pause choice and its
+     * "clocks paused" line read each state's word.
+     */
+    HUMAN_DECISION_PAUSE_STATE = "HumanDecisionPauseState"
+}
+/**
+ * What a value of a declared vocabulary may contain: it is also the LAST SEGMENT of its label key
+ * (`system_enums.<name>.<value>`), and the label tree is addressed by dotted path. A dotted value would name a label
+ * nobody could resolve, so it would render raw forever with nothing reporting why; every declaration of an
+ * `ApplicationConfigVocabulary` value refuses one that fails this test. One source, so the declarations cannot drift.
+ */
+export declare const LABEL_KEY_SEGMENT_PATTERN: RegExp;
+/** Whether `value` can be the last segment of a label key — see `LABEL_KEY_SEGMENT_PATTERN`. */
+export declare function isLabelKeySegment(value: string): boolean;
+//# sourceMappingURL=application-config-vocabulary.shared.d.ts.map

package/dist/esm/i18n/application-config-vocabulary.shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-config-vocabulary.shared.d.ts","sourceRoot":"","sources":["../../../../src/i18n/application-config-vocabulary.shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,oBAAY,2BAA2B;IACrC,4GAA4G;IAC5G,sBAAsB,wBAAwB;IAC9C,6HAA6H;IAC7H,iBAAiB,qBAAqB;IACtC;;;;OAIG;IACH,0BAA0B,4BAA4B;CACvD;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAA2B,CAAC;AAEpE,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAExD"}

package/dist/esm/i18n/application-config-vocabulary.shared.js

@@ -0,0 +1,39 @@
+/**
+ * The vocabularies whose NAME the framework owns and whose VALUES an application declares. "Config" is meant broadly:
+ * an application's declarations, in its configuration (`agentWorkReview.reasonCodes`, `organizationTypes`) or in what
+ * its backend modules register (a gate's `pauseStates`, #1864).
+ *
+ * The labelling planner reads each one's values where the application declares them — the configuration, or the
+ * backend introspection for a gate's pause states — and words them under `system_enums.<name>.<value>`, and a surface
+ * that shows one of the values reads the same key. So a value the application declares is worded the moment it is
+ * declared, and one it removes stops being planned, with no list of the application's values kept anywhere.
+ *
+ * The engine's own open vocabularies, whose values the ENGINE declares, are `EngineOpenVocabulary`.
+ *
+ * Kept in its own file with no imports, so a schema can name its vocabulary without importing anything else.
+ */
+export var ApplicationConfigVocabulary;
+(function (ApplicationConfigVocabulary) {
+    /** The reasons an expert may give for correcting an agent's work (`agentWorkReview.reasonCodes`, #1921). */
+    ApplicationConfigVocabulary["AGENT_WORK_REASON_CODE"] = "AgentWorkReasonCode";
+    /** The organization types an application declares (`organizationTypes`, keyed by type): an organization's `type` (#1851). */
+    ApplicationConfigVocabulary["ORGANIZATION_TYPE"] = "OrganizationType";
+    /**
+     * Why a reviewer may stop a decision's clocks: the pause states every approval gate declares
+     * (`humanApproval.deadlines.pauseStates` on a function tool, #1864). The approval inbox's Pause choice and its
+     * "clocks paused" line read each state's word.
+     */
+    ApplicationConfigVocabulary["HUMAN_DECISION_PAUSE_STATE"] = "HumanDecisionPauseState";
+})(ApplicationConfigVocabulary || (ApplicationConfigVocabulary = {}));
+/**
+ * What a value of a declared vocabulary may contain: it is also the LAST SEGMENT of its label key
+ * (`system_enums.<name>.<value>`), and the label tree is addressed by dotted path. A dotted value would name a label
+ * nobody could resolve, so it would render raw forever with nothing reporting why; every declaration of an
+ * `ApplicationConfigVocabulary` value refuses one that fails this test. One source, so the declarations cannot drift.
+ */
+export const LABEL_KEY_SEGMENT_PATTERN = /^[A-Za-z0-9_-]+$/;
+/** Whether `value` can be the last segment of a label key — see `LABEL_KEY_SEGMENT_PATTERN`. */
+export function isLabelKeySegment(value) {
+    return LABEL_KEY_SEGMENT_PATTERN.test(value);
+}
+//# sourceMappingURL=application-config-vocabulary.shared.js.map

package/dist/esm/i18n/application-config-vocabulary.shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-config-vocabulary.shared.js","sourceRoot":"","sources":["../../../../src/i18n/application-config-vocabulary.shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAN,IAAY,2BAWX;AAXD,WAAY,2BAA2B;IACrC,4GAA4G;IAC5G,6EAA8C,CAAA;IAC9C,6HAA6H;IAC7H,qEAAsC,CAAA;IACtC;;;;OAIG;IACH,qFAAsD,CAAA;AACxD,CAAC,EAXW,2BAA2B,KAA3B,2BAA2B,QAWtC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAW,kBAAkB,CAAC;AAEpE,gGAAgG;AAChG,MAAM,UAAU,iBAAiB,CAAC,KAAa;IAC7C,OAAO,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC/C,CAAC","sourcesContent":["/**\n * The vocabularies whose NAME the framework owns and whose VALUES an application declares. \"Config\" is meant broadly:\n * an application's declarations, in its configuration (`agentWorkReview.reasonCodes`, `organizationTypes`) or in what\n * its backend modules register (a gate's `pauseStates`, #1864).\n *\n * The labelling planner reads each one's values where the application declares them — the configuration, or the\n * backend introspection for a gate's pause states — and words them under `system_enums.<name>.<value>`, and a surface\n * that shows one of the values reads the same key. So a value the application declares is worded the moment it is\n * declared, and one it removes stops being planned, with no list of the application's values kept anywhere.\n *\n * The engine's own open vocabularies, whose values the ENGINE declares, are `EngineOpenVocabulary`.\n *\n * Kept in its own file with no imports, so a schema can name its vocabulary without importing anything else.\n */\nexport enum ApplicationConfigVocabulary {\n  /** The reasons an expert may give for correcting an agent's work (`agentWorkReview.reasonCodes`, #1921). */\n  AGENT_WORK_REASON_CODE = 'AgentWorkReasonCode',\n  /** The organization types an application declares (`organizationTypes`, keyed by type): an organization's `type` (#1851). */\n  ORGANIZATION_TYPE = 'OrganizationType',\n  /**\n   * Why a reviewer may stop a decision's clocks: the pause states every approval gate declares\n   * (`humanApproval.deadlines.pauseStates` on a function tool, #1864). The approval inbox's Pause choice and its\n   * \"clocks paused\" line read each state's word.\n   */\n  HUMAN_DECISION_PAUSE_STATE = 'HumanDecisionPauseState',\n}\n\n/**\n * What a value of a declared vocabulary may contain: it is also the LAST SEGMENT of its label key\n * (`system_enums.<name>.<value>`), and the label tree is addressed by dotted path. A dotted value would name a label\n * nobody could resolve, so it would render raw forever with nothing reporting why; every declaration of an\n * `ApplicationConfigVocabulary` value refuses one that fails this test. One source, so the declarations cannot drift.\n */\nexport const LABEL_KEY_SEGMENT_PATTERN: RegExp = /^[A-Za-z0-9_-]+$/;\n\n/** Whether `value` can be the last segment of a label key — see `LABEL_KEY_SEGMENT_PATTERN`. */\nexport function isLabelKeySegment(value: string): boolean {\n  return LABEL_KEY_SEGMENT_PATTERN.test(value);\n}\n"]}

package/dist/esm/i18n/engine-open-vocabulary-values.shared.d.ts

@@ -0,0 +1,11 @@
+import { EngineOpenVocabulary } from './engine-open-vocabulary.shared';
+/**
+ * The values of each {@link EngineOpenVocabulary}, which the labelling planner words under
+ * `system_enums.<name>.<value>` for every application (#1791).
+ *
+ * A `Record` keyed on the enum, so a vocabulary added there without its values is a compile error here rather
+ * than a vocabulary that renders its identifiers for ever. Derived from the engine's own enums, so a member added
+ * to one of them is planned on the next labelling run with no edit here.
+ */
+export declare const ENGINE_OPEN_VOCABULARY_VALUES: Readonly<Record<EngineOpenVocabulary, readonly string[]>>;
+//# sourceMappingURL=engine-open-vocabulary-values.shared.d.ts.map

package/dist/esm/i18n/engine-open-vocabulary-values.shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-open-vocabulary-values.shared.d.ts","sourceRoot":"","sources":["../../../../src/i18n/engine-open-vocabulary-values.shared.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAEvE;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,MAAM,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAC,CAEnG,CAAC"}

package/dist/esm/i18n/engine-open-vocabulary-values.shared.js

@@ -0,0 +1,14 @@
+import { CoreAuditableEventType } from '../compliance/audit-trails/auditable-events.shared.schema.js';
+import { EngineOpenVocabulary } from './engine-open-vocabulary.shared.js';
+/**
+ * The values of each {@link EngineOpenVocabulary}, which the labelling planner words under
+ * `system_enums.<name>.<value>` for every application (#1791).
+ *
+ * A `Record` keyed on the enum, so a vocabulary added there without its values is a compile error here rather
+ * than a vocabulary that renders its identifiers for ever. Derived from the engine's own enums, so a member added
+ * to one of them is planned on the next labelling run with no edit here.
+ */
+export const ENGINE_OPEN_VOCABULARY_VALUES = {
+    [EngineOpenVocabulary.CORE_AUDITABLE_EVENT_TYPE]: Object.values(CoreAuditableEventType),
+};
+//# sourceMappingURL=engine-open-vocabulary-values.shared.js.map

package/dist/esm/i18n/engine-open-vocabulary-values.shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-open-vocabulary-values.shared.js","sourceRoot":"","sources":["../../../../src/i18n/engine-open-vocabulary-values.shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,2DAA2D,CAAC;AACnG,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAEvE;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAA8D;IACtG,CAAC,oBAAoB,CAAC,yBAAyB,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC;CACxF,CAAC","sourcesContent":["import { CoreAuditableEventType } from '../compliance/audit-trails/auditable-events.shared.schema';\nimport { EngineOpenVocabulary } from './engine-open-vocabulary.shared';\n\n/**\n * The values of each {@link EngineOpenVocabulary}, which the labelling planner words under\n * `system_enums.<name>.<value>` for every application (#1791).\n *\n * A `Record` keyed on the enum, so a vocabulary added there without its values is a compile error here rather\n * than a vocabulary that renders its identifiers for ever. Derived from the engine's own enums, so a member added\n * to one of them is planned on the next labelling run with no edit here.\n */\nexport const ENGINE_OPEN_VOCABULARY_VALUES: Readonly<Record<EngineOpenVocabulary, readonly string[]>> = {\n  [EngineOpenVocabulary.CORE_AUDITABLE_EVENT_TYPE]: Object.values(CoreAuditableEventType),\n};\n"]}

package/dist/esm/i18n/engine-open-vocabulary.shared.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The engine's OPEN vocabularies (#1791): named sets of values that a STRING field carries and the engine declares
+ * outside any schema.
+ *
+ * `z.enum` is how a field normally names its vocabulary, and it lets the labeller read the values off the field.
+ * Some fields cannot be an enum because the schema does not own their values. An audit event's `eventType` is a
+ * string, because an event type is written by whoever emits it. Such a field declares its vocabulary with
+ * `.systemEnum(EngineOpenVocabulary.X)`: the display reads `system_enums.<name>.<value>`, and the labeller plans
+ * those keys from {@link ENGINE_OPEN_VOCABULARY_VALUES}, the one place the values are listed.
+ *
+ * A vocabulary whose values an APPLICATION declares is not here: those are `ApplicationConfigVocabulary`, and the
+ * labeller reads their values from the application's configuration.
+ *
+ * Kept in its own file with no imports, so a schema can name its vocabulary without importing the values.
+ */
+export declare enum EngineOpenVocabulary {
+    /** Every `CoreAuditableEventType` the engine emits: the words an audit trail shows for an event. */
+    CORE_AUDITABLE_EVENT_TYPE = "CoreAuditableEventType"
+}
+//# sourceMappingURL=engine-open-vocabulary.shared.d.ts.map

package/dist/esm/i18n/engine-open-vocabulary.shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-open-vocabulary.shared.d.ts","sourceRoot":"","sources":["../../../../src/i18n/engine-open-vocabulary.shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,oBAAY,oBAAoB;IAC9B,oGAAoG;IACpG,yBAAyB,2BAA2B;CACrD"}

package/dist/esm/i18n/engine-open-vocabulary.shared.js

@@ -0,0 +1,21 @@
+/**
+ * The engine's OPEN vocabularies (#1791): named sets of values that a STRING field carries and the engine declares
+ * outside any schema.
+ *
+ * `z.enum` is how a field normally names its vocabulary, and it lets the labeller read the values off the field.
+ * Some fields cannot be an enum because the schema does not own their values. An audit event's `eventType` is a
+ * string, because an event type is written by whoever emits it. Such a field declares its vocabulary with
+ * `.systemEnum(EngineOpenVocabulary.X)`: the display reads `system_enums.<name>.<value>`, and the labeller plans
+ * those keys from {@link ENGINE_OPEN_VOCABULARY_VALUES}, the one place the values are listed.
+ *
+ * A vocabulary whose values an APPLICATION declares is not here: those are `ApplicationConfigVocabulary`, and the
+ * labeller reads their values from the application's configuration.
+ *
+ * Kept in its own file with no imports, so a schema can name its vocabulary without importing the values.
+ */
+export var EngineOpenVocabulary;
+(function (EngineOpenVocabulary) {
+    /** Every `CoreAuditableEventType` the engine emits: the words an audit trail shows for an event. */
+    EngineOpenVocabulary["CORE_AUDITABLE_EVENT_TYPE"] = "CoreAuditableEventType";
+})(EngineOpenVocabulary || (EngineOpenVocabulary = {}));
+//# sourceMappingURL=engine-open-vocabulary.shared.js.map

package/dist/esm/i18n/engine-open-vocabulary.shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-open-vocabulary.shared.js","sourceRoot":"","sources":["../../../../src/i18n/engine-open-vocabulary.shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAN,IAAY,oBAGX;AAHD,WAAY,oBAAoB;IAC9B,oGAAoG;IACpG,4EAAoD,CAAA;AACtD,CAAC,EAHW,oBAAoB,KAApB,oBAAoB,QAG/B","sourcesContent":["/**\n * The engine's OPEN vocabularies (#1791): named sets of values that a STRING field carries and the engine declares\n * outside any schema.\n *\n * `z.enum` is how a field normally names its vocabulary, and it lets the labeller read the values off the field.\n * Some fields cannot be an enum because the schema does not own their values. An audit event's `eventType` is a\n * string, because an event type is written by whoever emits it. Such a field declares its vocabulary with\n * `.systemEnum(EngineOpenVocabulary.X)`: the display reads `system_enums.<name>.<value>`, and the labeller plans\n * those keys from {@link ENGINE_OPEN_VOCABULARY_VALUES}, the one place the values are listed.\n *\n * A vocabulary whose values an APPLICATION declares is not here: those are `ApplicationConfigVocabulary`, and the\n * labeller reads their values from the application's configuration.\n *\n * Kept in its own file with no imports, so a schema can name its vocabulary without importing the values.\n */\nexport enum EngineOpenVocabulary {\n  /** Every `CoreAuditableEventType` the engine emits: the words an audit trail shows for an event. */\n  CORE_AUDITABLE_EVENT_TYPE = 'CoreAuditableEventType',\n}\n"]}

package/dist/esm/i18n/labelling.dto.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"labelling.dto.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/i18n/labelling.dto.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAExE,QAAA,MAAM,qBAAqB;;;;;iBAKzB,CAAC;AAEH,eAAO,MAAM,oBAAoB,EAAE,OAAO,qBAA6C,CAAC;AACxF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEnE,QAAA,MAAM,2BAA2B;;;;iBAK/B,CAAC;AAEH,eAAO,MAAM,0BAA0B,EAAE,OAAO,2BAAyD,CAAC;AAC1G,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAE/E,QAAA,MAAM,4BAA4B;;;;iBAIhC,CAAC;AAEH,eAAO,MAAM,2BAA2B,EAAE,OAAO,4BAA2D,CAAC;AAC7G,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}
+{"version":3,"file":"labelling.dto.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/i18n/labelling.dto.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAExE,QAAA,MAAM,qBAAqB;;;;;iBAKzB,CAAC;AAEH,eAAO,MAAM,oBAAoB,EAAE,OAAO,qBAA6C,CAAC;AACxF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEnE,QAAA,MAAM,2BAA2B;;;;iBAK/B,CAAC;AAEH,eAAO,MAAM,0BAA0B,EAAE,OAAO,2BAAyD,CAAC;AAC1G,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAE/E,QAAA,MAAM,4BAA4B;;;;iBAIhC,CAAC;AAEH,eAAO,MAAM,2BAA2B,EAAE,OAAO,4BAA2D,CAAC;AAC7G,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/esm/inbound/conversation-threads.shared.resources-config.schemas.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Conversation threads, messages and reply tokens — resource configurations (#1630).
+ *
+ * The engine writes all three: the channel intake opens threads and records received messages,
+ * `ctx.reply` records replies, the reply worker settles them, and the token service issues and revokes
+ * tokens. None of those writes is an HTTP surface (CREATE / UPDATE are REPOSITORY_ONLY), so no caller can
+ * backdate a closure or invent a message.
+ *
+ * What a person may do: members of the organization READ its threads and messages (the correspondence of
+ * the organization's own cases), and an organization administrator CLOSES a thread. Tokens have no API at
+ * all — a reply address is a bearer secret, and the list of them is nobody's business but the engine's.
+ *
+ * DELETE / DELETE_MANY / UPDATE_MANY are INTERNAL_CALL: the retention sweep deletes expired rows through the
+ * service layer (a closed thread's tokens go with it), and the erasure writer scrubs through UPDATE_MANY.
+ * Route-less, so reachable by no request.
+ */
+import { z } from 'zod';
+import { CoreResourceOperation } from '../resources/resources.shared.core.definitions';
+import { type ResourceRelationship } from '../resources/resources.shared.schemas';
+import { ConversationMessageDirection, ConversationThreadStatus, ConversationThreads_Operations } from './conversation-threads.shared.schemas';
+/**
+ * The two `conversationThreads` LIST filter keys that find the conversations linked to one record (#1630): dotted
+ * paths into `linkedResource`. One source for the backend's `filterFields` and for the frontend embed that pins them
+ * (`EmbedLinkedConversations`), so the two cannot disagree on a spelling.
+ */
+export declare const CONVERSATION_THREAD_LINKED_RESOURCE_FILTER: {
+    readonly RESOURCE_TYPE: "linkedResource.resourceType";
+    readonly RESOURCE_ID: "linkedResource.resourceId";
+};
+type ConversationCoreOperations = CoreResourceOperation.READ | CoreResourceOperation.LIST | CoreResourceOperation.CREATE | CoreResourceOperation.UPDATE | CoreResourceOperation.UPDATE_MANY | CoreResourceOperation.DELETE | CoreResourceOperation.DELETE_MANY;
+export declare const conversationThreadsResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => import("..").ResourceConfiguration<typeof ConversationThreads_Operations, ConversationCoreOperations, import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    organizationId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    channel: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("./inbound-channels.shared.schemas").InboundChannelKind>>>>;
+    threadKey: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    counterpartAddress: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    subject: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodString>>>;
+    linkedResource: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strict>>>;
+    status: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ConversationThreadStatus>>>>>;
+    lastMessageAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>;
+    closedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>>>;
+    createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>>;
+    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
+}, z.core.$strip>>>;
+export declare const conversationMessagesResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => import("..").ResourceConfiguration<Record<string, never>, ConversationCoreOperations, z.ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    organizationId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    threadId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    direction: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ConversationMessageDirection>>>>;
+    rfcMessageId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    fromAddress: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    toAddresses: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    subject: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodString>>;
+    textPreview: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodString>>;
+    occurredAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>;
+    inboundDeliveryId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    channelRecordRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strict>>>>;
+    submissionId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    outboundStatus: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("./conversation-threads.shared.schemas").ConversationOutboundStatus>>>>>>>;
+    templateRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+    templateVariables: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>>;
+    locale: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+    replyToAddress: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    threading: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        inReplyTo: z.ZodOptional<z.ZodString>;
+        references: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>>;
+    providerMessageIds: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodArray<z.ZodString>>>>;
+    failureCode: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<z.ZodString>>>>;
+    settledAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<z.ZodDate>>>>;
+    createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>>;
+    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
+}, z.core.$strip>>;
+export declare const conversationReplyTokensResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => import("..").ResourceConfiguration<Record<string, never>, ConversationCoreOperations, z.ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    organizationId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    threadId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    recipientAddress: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    recipientMemberUserId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+    tokenHash: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    issuedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>;
+    revokedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>>>;
+    revocationReason: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("./conversation-threads.shared.schemas").ReplyTokenRevocationReason>>>>>>;
+    createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>>;
+    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
+}, z.core.$strip>>;
+export {};
+//# sourceMappingURL=conversation-threads.shared.resources-config.schemas.d.ts.map

package/dist/esm/inbound/conversation-threads.shared.resources-config.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-threads.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../../src/inbound/conversation-threads.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,qBAAqB,EAAwD,MAAM,gDAAgD,CAAC;AAC7I,OAAO,EAA4D,KAAK,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAO5I,OAAO,EACL,4BAA4B,EAI5B,wBAAwB,EACxB,8BAA8B,EAC/B,MAAM,uCAAuC,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,0CAA0C;;;CAG7C,CAAC;AAEX,KAAK,0BAA0B,GAC3B,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,MAAM,GAC5B,qBAAqB,CAAC,MAAM,GAC5B,qBAAqB,CAAC,WAAW,GACjC,qBAAqB,CAAC,MAAM,GAC5B,qBAAqB,CAAC,WAAW,CAAC;AAoCtC,eAAO,MAAM,8DAA8D,GAAI,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;mBAoEzH,CAAC;AAEL,eAAO,MAAM,+DAA+D,GAAI,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmD1H,CAAC;AAEL,eAAO,MAAM,kEAAkE,GAAI,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;kBAsB7H,CAAC"}

package/dist/esm/inbound/conversation-threads.shared.resources-config.schemas.js

@@ -0,0 +1,206 @@
+/**
+ * Conversation threads, messages and reply tokens — resource configurations (#1630).
+ *
+ * The engine writes all three: the channel intake opens threads and records received messages,
+ * `ctx.reply` records replies, the reply worker settles them, and the token service issues and revokes
+ * tokens. None of those writes is an HTTP surface (CREATE / UPDATE are REPOSITORY_ONLY), so no caller can
+ * backdate a closure or invent a message.
+ *
+ * What a person may do: members of the organization READ its threads and messages (the correspondence of
+ * the organization's own cases), and an organization administrator CLOSES a thread. Tokens have no API at
+ * all — a reply address is a bearer secret, and the list of them is nobody's business but the engine's.
+ *
+ * DELETE / DELETE_MANY / UPDATE_MANY are INTERNAL_CALL: the retention sweep deletes expired rows through the
+ * service layer (a closed thread's tokens go with it), and the erasure writer scrubs through UPDATE_MANY.
+ * Route-less, so reachable by no request.
+ */
+import { z } from 'zod';
+import { CoreResourceOperation, CoreResourceType, coreResourceShared_FieldIdentifier } from '../resources/resources.shared.core.definitions.js';
+import { ResourceOperationRiskLevel, ResourceOperationVariantType } from '../resources/resources.shared.schemas.js';
+import { createResourceConfiguration_Initialization } from '../resources/resources-config.shared.factory.js';
+import { ResourceSystemAccessMode } from '../resources/resources-config.shared.schemas.js';
+import { WorkUnitRefSchema } from '../resources/work-unit.shared.schemas.js';
+import { CORE_APP_ROLES, CORE_ORG_ROLES } from '../security/authorizations/roles.shared.schemas.js';
+import { ErasureRetentionMode, ResourceDataSubjectKind, StatutoryRetentionGround } from '../compliance/privacy/impersonalization.shared.schemas.js';
+import { DataRetentionClass, RetentionStartPoint } from '../compliance/privacy/retention-schedule.shared.schemas.js';
+import { ConversationMessageDirection, ConversationMessageSchema, ConversationReplyTokenSchema, ConversationThreadSchema, ConversationThreadStatus, ConversationThreads_Operations, } from './conversation-threads.shared.schemas.js';
+/**
+ * The two `conversationThreads` LIST filter keys that find the conversations linked to one record (#1630): dotted
+ * paths into `linkedResource`. One source for the backend's `filterFields` and for the frontend embed that pins them
+ * (`EmbedLinkedConversations`), so the two cannot disagree on a spelling.
+ */
+export const CONVERSATION_THREAD_LINKED_RESOURCE_FILTER = {
+    RESOURCE_TYPE: 'linkedResource.resourceType',
+    RESOURCE_ID: 'linkedResource.resourceId',
+};
+const CORE_OPERATIONS = [
+    CoreResourceOperation.READ,
+    CoreResourceOperation.LIST,
+    CoreResourceOperation.CREATE,
+    CoreResourceOperation.UPDATE,
+    CoreResourceOperation.UPDATE_MANY,
+    CoreResourceOperation.DELETE,
+    CoreResourceOperation.DELETE_MANY,
+];
+/**
+ * The engine reads threads and tokens on a system context to correlate a message BEFORE any handler
+ * authority exists, and the intake, reply worker and token service write them as the engine.
+ */
+const engineOwned = {
+    read: ResourceSystemAccessMode.ALLOWED,
+    list: ResourceSystemAccessMode.ALLOWED,
+    create: ResourceSystemAccessMode.ALLOWED,
+    update: ResourceSystemAccessMode.ALLOWED,
+    updateMany: ResourceSystemAccessMode.ALLOWED,
+};
+/** Retained on erasure, scrubbed of the addresses and the text; the thread's structure is the record. */
+const RETAIN = { mode: ErasureRetentionMode.RETAIN_AND_IMPERSONALIZE };
+/** The counterpart is a person with no account, or another organization: no login is reachable from a row. */
+const NO_PRINCIPAL = { kind: ResourceDataSubjectKind.NO_PRINCIPAL };
+/*
+ * The operation configurations below are written out per resource rather than shared through a helper:
+ * contextual typing needs each variant literal in place, and a shared constant widens `variantType` to the
+ * whole enum, which the builder refuses.
+ */
+export const conversationThreadsResourceConfiguration_InitializationFactory = (resourcesRelationships) => createResourceConfiguration_Initialization({
+    mainSchema: ConversationThreadSchema,
+    resourceIdentifier: CoreResourceType.CONVERSATION_THREADS,
+    resourceFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.CONVERSATION_THREADS],
+    resourceRelationships: resourcesRelationships,
+    isSystemResource: true,
+    systemAccessPolicy: engineOwned,
+    retentionPolicy: RETAIN,
+    /*
+     * A thread is CORRELATION, not the record (#1613, #1635): its messages are the business letters a
+     * statute keeps, and each carries its own statutory clock. So a thread is kept while the exchange may
+     * continue and for the application's `RESOURCE_DATA` period after it CLOSES — an open thread never
+     * expires — and deleting it takes its reply tokens but never its messages (the edge to them is a
+     * REFERENCE), which stand on their own until their statutory period ends.
+     */
+    retentionBinding: {
+        retentionClass: DataRetentionClass.RESOURCE_DATA,
+        startPoint: RetentionStartPoint.CLOSURE_EVENT,
+        closureFieldName: 'closedAt',
+    },
+    dataSubjectPolicy: NO_PRINCIPAL,
+    coreOperations: CORE_OPERATIONS,
+    operationsConfiguration: {
+        [CoreResourceOperation.READ]: { variants: [{ variantType: ResourceOperationVariantType.API_CALL, isDefault: true, roles: [CORE_ORG_ROLES.ORG_MEMBER], riskLevel: ResourceOperationRiskLevel.LOW }] },
+        /*
+         * `linkedResource.*` lets a record's page find the conversations linked to it. Dotted keys into the stored
+         * object rather than a copy of the link in two top-level columns: one source for the link, and both
+         * adapters filter on a path (MongoDB natively, PostgreSQL through the jsonb root the object is stored in).
+         */
+        [CoreResourceOperation.LIST]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.API_CALL,
+                    isDefault: true,
+                    roles: [CORE_ORG_ROLES.ORG_MEMBER],
+                    riskLevel: ResourceOperationRiskLevel.LOW,
+                    filterFields: {
+                        status: z.enum(ConversationThreadStatus),
+                        // The link's own field schemas, not bare strings: a filter on a field is that field, so it carries the
+                        // field's limits and its description into every LIST variant's published query parameters (#1625).
+                        [CONVERSATION_THREAD_LINKED_RESOURCE_FILTER.RESOURCE_TYPE]: WorkUnitRefSchema.shape.resourceType,
+                        [CONVERSATION_THREAD_LINKED_RESOURCE_FILTER.RESOURCE_ID]: WorkUnitRefSchema.shape.resourceId,
+                    },
+                    sortFields: ['lastMessageAt', 'createdAt'],
+                }],
+        },
+        [CoreResourceOperation.CREATE]: { variants: [{ variantType: ResourceOperationVariantType.REPOSITORY_ONLY, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.LOW }] },
+        [CoreResourceOperation.UPDATE]: { variants: [{ variantType: ResourceOperationVariantType.REPOSITORY_ONLY, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.LOW }] },
+        [CoreResourceOperation.UPDATE_MANY]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.CRITICAL }] },
+        // HIGH: deleting correspondence removes evidence of what a client sent and what the firm answered.
+        [CoreResourceOperation.DELETE]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [], riskLevel: ResourceOperationRiskLevel.HIGH }] },
+        [CoreResourceOperation.DELETE_MANY]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [], riskLevel: ResourceOperationRiskLevel.HIGH }] },
+        /**
+         * Close the exchange. Revokes every live reply token of the thread (a reply to it no longer binds),
+         * and starts the retention clock. Empty request: the implementation owns the transition.
+         */
+        [ConversationThreads_Operations.CLOSE]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.API_CALL,
+                    isDefault: true,
+                    roles: [CORE_ORG_ROLES.ORG_ADMIN],
+                    riskLevel: ResourceOperationRiskLevel.MEDIUM,
+                    resourceOperationLike: CoreResourceOperation.UPDATE,
+                    requestDto: z.object({}),
+                    enabledCondition: ({ currentObject }) => currentObject.status === ConversationThreadStatus.OPEN,
+                }],
+        },
+    },
+});
+export const conversationMessagesResourceConfiguration_InitializationFactory = (resourcesRelationships) => createResourceConfiguration_Initialization({
+    mainSchema: ConversationMessageSchema,
+    resourceIdentifier: CoreResourceType.CONVERSATION_MESSAGES,
+    resourceFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.CONVERSATION_MESSAGES],
+    resourceRelationships: resourcesRelationships,
+    isSystemResource: true,
+    systemAccessPolicy: engineOwned,
+    /*
+     * Every message — received or sent — is business correspondence, which commercial and tax statutes
+     * require kept for a period counted from the end of the calendar year it was received or sent. So an
+     * erasure RESTRICTS a message inside that period instead of scrubbing it (#1635), and the sweep deletes
+     * it once the application's `BUSINESS_RECORDS` period has passed.
+     *
+     * `RETAIN_AND_IMPERSONALIZE`, not `RETAIN_ONLY`: `RETAIN_ONLY` declares that the row holds no personal
+     * data of its own, and a message holds addresses, a subject and a preview. The mode states what the row
+     * IS; the statutory ground decides that, inside its period, erasure restricts rather than scrubs.
+     */
+    retentionPolicy: {
+        mode: ErasureRetentionMode.RETAIN_AND_IMPERSONALIZE,
+        statutoryRetention: {
+            ground: StatutoryRetentionGround.LEGAL_OBLIGATION,
+            rationale: 'Business correspondence received and sent: HGB §257(1) no. 2-3 and AO §147(1) no. 2-3 (six years, counted from the end of the calendar year, §257(5) / §147(4)); Code de commerce L123-22 where it is accounting evidence.',
+        },
+    },
+    retentionBinding: {
+        retentionClass: DataRetentionClass.BUSINESS_RECORDS,
+        startPoint: RetentionStartPoint.END_OF_CALENDAR_YEAR,
+    },
+    dataSubjectPolicy: NO_PRINCIPAL,
+    coreOperations: CORE_OPERATIONS,
+    operationsConfiguration: {
+        [CoreResourceOperation.READ]: { variants: [{ variantType: ResourceOperationVariantType.API_CALL, isDefault: true, roles: [CORE_ORG_ROLES.ORG_MEMBER], riskLevel: ResourceOperationRiskLevel.LOW }] },
+        // A thread's messages, newest first by default or sorted by `occurredAt`; `direction` tells what was received from what was answered.
+        [CoreResourceOperation.LIST]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.API_CALL,
+                    isDefault: true,
+                    roles: [CORE_ORG_ROLES.ORG_MEMBER],
+                    riskLevel: ResourceOperationRiskLevel.LOW,
+                    filterFields: { threadId: z.string(), direction: z.enum(ConversationMessageDirection) },
+                    sortFields: ['occurredAt'],
+                }],
+        },
+        [CoreResourceOperation.CREATE]: { variants: [{ variantType: ResourceOperationVariantType.REPOSITORY_ONLY, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.LOW }] },
+        [CoreResourceOperation.UPDATE]: { variants: [{ variantType: ResourceOperationVariantType.REPOSITORY_ONLY, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.LOW }] },
+        [CoreResourceOperation.UPDATE_MANY]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.CRITICAL }] },
+        // HIGH: deleting correspondence removes evidence of what a client sent and what the firm answered.
+        [CoreResourceOperation.DELETE]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [], riskLevel: ResourceOperationRiskLevel.HIGH }] },
+        [CoreResourceOperation.DELETE_MANY]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [], riskLevel: ResourceOperationRiskLevel.HIGH }] },
+    },
+});
+export const conversationReplyTokensResourceConfiguration_InitializationFactory = (resourcesRelationships) => createResourceConfiguration_Initialization({
+    mainSchema: ConversationReplyTokenSchema,
+    resourceIdentifier: CoreResourceType.CONVERSATION_REPLY_TOKENS,
+    resourceFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.CONVERSATION_REPLY_TOKENS],
+    resourceRelationships: resourcesRelationships,
+    isSystemResource: true,
+    systemAccessPolicy: engineOwned,
+    retentionPolicy: RETAIN,
+    dataSubjectPolicy: NO_PRINCIPAL,
+    coreOperations: CORE_OPERATIONS,
+    operationsConfiguration: {
+        // No API read: a reply address is a bearer secret, and knowing which exist is the engine's alone.
+        [CoreResourceOperation.READ]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.LOW }] },
+        [CoreResourceOperation.LIST]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.LOW }] },
+        [CoreResourceOperation.CREATE]: { variants: [{ variantType: ResourceOperationVariantType.REPOSITORY_ONLY, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.LOW }] },
+        [CoreResourceOperation.UPDATE]: { variants: [{ variantType: ResourceOperationVariantType.REPOSITORY_ONLY, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.LOW }] },
+        [CoreResourceOperation.UPDATE_MANY]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN], riskLevel: ResourceOperationRiskLevel.CRITICAL }] },
+        // Route-less: a token leaves with its thread (the COMPOSITION cascade), never on its own.
+        [CoreResourceOperation.DELETE]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [], riskLevel: ResourceOperationRiskLevel.HIGH }] },
+        [CoreResourceOperation.DELETE_MANY]: { variants: [{ variantType: ResourceOperationVariantType.INTERNAL_CALL, isDefault: true, roles: [], riskLevel: ResourceOperationRiskLevel.HIGH }] },
+    },
+});
+//# sourceMappingURL=conversation-threads.shared.resources-config.schemas.js.map