@mj-biz-apps/contracts-entities 0.1.0

package/dist/ContractTemplateEntity.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview `ContractTemplateEntity` — the publication lifecycle, and the one rule that makes it
+ * mean anything.
+ *
+ * A template version is either a **Draft** (freely editable, not referenceable) or **Published**
+ * (frozen, referenceable). The freeze itself is enforced by
+ * `trg_ContractTemplateProvision_Immutability` against INSERT, UPDATE and DELETE on its provisions —
+ * a trigger, because rewriting signed terms is the case where a bypass is silent corruption rather
+ * than a bad edit in our own UI.
+ *
+ * WHAT LIVES HERE IS THE TRANSITION RULE, which the trigger cannot see: **publishing is one-way.**
+ * Without it the freeze is decorative — anyone wanting to edit a published version would flip
+ * `Status` back to Draft, edit, and flip it forward again, and every guarantee above evaporates. To
+ * change published terms you publish a NEW VERSION, which is what `VersionLabel` and `IntroducedDate`
+ * exist for.
+ *
+ * WHY NOT A CHECK CONSTRAINT: a CHECK sees one row's final state, not the transition. "Was Published,
+ * is now Draft" is a comparison against `OldValue`, which only the entity layer has.
+ *
+ * WHY PROVISION-LEVEL DEACTIVATION WAS REJECTED (Marcelo, 2026-08-20), recorded so it is not
+ * re-proposed: soft-deleting provisions would build a second, finer-grained versioning system beside
+ * the one that already exists, and "what did this customer sign" would degrade from "template T" into
+ * "the provisions of T that were active on date X" — a temporal query, which is exactly what
+ * versioning avoids. The lifecycle belongs to the VERSION, not to the clause.
+ *
+ * @module @mj-biz-apps/contracts-entities
+ */
+import { ValidationResult } from '@memberjunction/core';
+import { mjBizAppsContractsContractTemplateEntity } from './generated/entity_subclasses.js';
+/** The published state — the string the `IN (...)` CHECK constrains `Status` to. */
+export declare const TEMPLATE_PUBLISHED = "Published";
+/** The editable state, and the default for a new version. */
+export declare const TEMPLATE_DRAFT = "Draft";
+export declare class ContractTemplateEntity extends mjBizAppsContractsContractTemplateEntity {
+    Validate(): ValidationResult;
+    /**
+     * Publishing is one-way: `Published` never returns to `Draft`.
+     *
+     * Compared against `OldValue` rather than probing anything, so it costs nothing and works on a
+     * record composed in the browser. Only fires on a SAVED record: a new version is legitimately
+     * created as a Draft, and there is no previous state to have been published.
+     */
+    private refuseUnpublishing;
+}
+/**
+ * Anti-tree-shake anchor. Importing this module is what fires `@RegisterClass`; a dropped registration
+ * would silently make publishing reversible, with nothing failing.
+ */
+export declare function LoadContractTemplateEntity(): void;
+//# sourceMappingURL=ContractTemplateEntity.d.ts.map

package/dist/ContractTemplateEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTemplateEntity.d.ts","sourceRoot":"","sources":["../src/ContractTemplateEntity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAwD,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE9G,OAAO,EAAE,wCAAwC,EAAE,MAAM,+BAA+B,CAAC;AAGzF,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAC9C,6DAA6D;AAC7D,eAAO,MAAM,cAAc,UAAU,CAAC;AAEtC,qBACa,sBAAuB,SAAQ,wCAAwC;IAChE,QAAQ,IAAI,gBAAgB;IAS5C;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;CAoB7B;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD"}

package/dist/ContractTemplateEntity.js

@@ -0,0 +1,85 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * @fileoverview `ContractTemplateEntity` — the publication lifecycle, and the one rule that makes it
+ * mean anything.
+ *
+ * A template version is either a **Draft** (freely editable, not referenceable) or **Published**
+ * (frozen, referenceable). The freeze itself is enforced by
+ * `trg_ContractTemplateProvision_Immutability` against INSERT, UPDATE and DELETE on its provisions —
+ * a trigger, because rewriting signed terms is the case where a bypass is silent corruption rather
+ * than a bad edit in our own UI.
+ *
+ * WHAT LIVES HERE IS THE TRANSITION RULE, which the trigger cannot see: **publishing is one-way.**
+ * Without it the freeze is decorative — anyone wanting to edit a published version would flip
+ * `Status` back to Draft, edit, and flip it forward again, and every guarantee above evaporates. To
+ * change published terms you publish a NEW VERSION, which is what `VersionLabel` and `IntroducedDate`
+ * exist for.
+ *
+ * WHY NOT A CHECK CONSTRAINT: a CHECK sees one row's final state, not the transition. "Was Published,
+ * is now Draft" is a comparison against `OldValue`, which only the entity layer has.
+ *
+ * WHY PROVISION-LEVEL DEACTIVATION WAS REJECTED (Marcelo, 2026-08-20), recorded so it is not
+ * re-proposed: soft-deleting provisions would build a second, finer-grained versioning system beside
+ * the one that already exists, and "what did this customer sign" would degrade from "template T" into
+ * "the provisions of T that were active on date X" — a temporal query, which is exactly what
+ * versioning avoids. The lifecycle belongs to the VERSION, not to the clause.
+ *
+ * @module @mj-biz-apps/contracts-entities
+ */
+import { BaseEntity, ValidationErrorInfo, ValidationErrorType } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import { mjBizAppsContractsContractTemplateEntity } from './generated/entity_subclasses.js';
+import { ValidateValueLists } from './value-list-validation.js';
+/** The published state — the string the `IN (...)` CHECK constrains `Status` to. */
+export const TEMPLATE_PUBLISHED = 'Published';
+/** The editable state, and the default for a new version. */
+export const TEMPLATE_DRAFT = 'Draft';
+let ContractTemplateEntity = class ContractTemplateEntity extends mjBizAppsContractsContractTemplateEntity {
+    Validate() {
+        const result = super.Validate();
+        // Status is an exhaustive value list with no generated validator — MJ never checks list
+        // membership (MJ#3969), so the generic stopgap covers it like the other lookup columns.
+        ValidateValueLists(this, result);
+        this.refuseUnpublishing(result);
+        return result;
+    }
+    /**
+     * Publishing is one-way: `Published` never returns to `Draft`.
+     *
+     * Compared against `OldValue` rather than probing anything, so it costs nothing and works on a
+     * record composed in the browser. Only fires on a SAVED record: a new version is legitimately
+     * created as a Draft, and there is no previous state to have been published.
+     */
+    refuseUnpublishing(result) {
+        if (!this.IsSaved)
+            return;
+        const field = this.GetFieldByName('Status');
+        if (!field)
+            return;
+        const was = String(field.OldValue ?? '');
+        const now = String(field.Value ?? '');
+        if (was !== TEMPLATE_PUBLISHED || now === TEMPLATE_PUBLISHED)
+            return;
+        result.Success = false;
+        result.Errors.push(new ValidationErrorInfo('Status', `"${this.Name ?? this.ID}" is published and cannot be returned to draft. Contracts may already ` +
+            `incorporate its terms, and un-publishing would let those terms be edited underneath them. ` +
+            `Create a new version of this agreement instead — that is what versioning is for.`, now, ValidationErrorType.Failure));
+    }
+};
+ContractTemplateEntity = __decorate([
+    RegisterClass(BaseEntity, 'MJ_BizApps_Contracts: Contract Templates')
+], ContractTemplateEntity);
+export { ContractTemplateEntity };
+/**
+ * Anti-tree-shake anchor. Importing this module is what fires `@RegisterClass`; a dropped registration
+ * would silently make publishing reversible, with nothing failing.
+ */
+export function LoadContractTemplateEntity() {
+    void ContractTemplateEntity;
+}
+//# sourceMappingURL=ContractTemplateEntity.js.map

package/dist/ContractTemplateEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTemplateEntity.js","sourceRoot":"","sources":["../src/ContractTemplateEntity.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,mBAAmB,EAAoB,MAAM,sBAAsB,CAAC;AAC9G,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,wCAAwC,EAAE,MAAM,+BAA+B,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D,oFAAoF;AACpF,MAAM,CAAC,MAAM,kBAAkB,GAAG,WAAW,CAAC;AAC9C,6DAA6D;AAC7D,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC;AAG/B,IAAM,sBAAsB,GAA5B,MAAM,sBAAuB,SAAQ,wCAAwC;IAChE,QAAQ;QACpB,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;QAChC,wFAAwF;QACxF,wFAAwF;QACxF,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACjC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAChC,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;;;;;OAMG;IACK,kBAAkB,CAAC,MAAwB;QAC/C,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;QACzC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;QACtC,IAAI,GAAG,KAAK,kBAAkB,IAAI,GAAG,KAAK,kBAAkB;YAAE,OAAO;QAErE,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,MAAM,CAAC,MAAM,CAAC,IAAI,CACd,IAAI,mBAAmB,CACnB,QAAQ,EACR,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,EAAE,wEAAwE;YAC5F,4FAA4F;YAC5F,kFAAkF,EACtF,GAAG,EACH,mBAAmB,CAAC,OAAO,CAC9B,CACJ,CAAC;IACN,CAAC;CACJ,CAAA;AArCY,sBAAsB;IADlC,aAAa,CAAC,UAAU,EAAE,0CAA0C,CAAC;GACzD,sBAAsB,CAqClC;;AAED;;;GAGG;AACH,MAAM,UAAU,0BAA0B;IACtC,KAAK,sBAAsB,CAAC;AAChC,CAAC"}

package/dist/ContractTemplateModificationEntity.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview `ContractTemplateModificationEntity` — the SHARED subclass, and it exists for exactly
+ * one reason: the three fields a modification cannot do without refuse in prose nobody can act on.
+ *
+ * IT ADDS NO RULE. That distinction is the whole design, and getting it wrong here is a known trap
+ * (R-2 of `plans/backend-requirements.md`, withdrawn because implementing it would have produced a
+ * second copy of four working generated rules). `ContractID`, `ContractTemplateProvisionID` and — as
+ * of V202608192340 — `ModificationText` are all NOT NULL in the database, so MJ's own
+ * `EntityField.Validate()` already refuses an empty one and already names the field. The rule is the
+ * metadata; restating it in TypeScript would give one fact two owners and let them drift the next
+ * time a column's nullability changes.
+ *
+ * What MJ cannot know is what the user should DO about it. Its message is
+ * `` `${DisplayNameOrName} cannot be null` `` (`baseEntity.ts:320`) — correct, field-named, and mute
+ * on the only question the person in front of the form is asking. "Contract Template Provision
+ * cannot be null" does not tell anyone to pick a clause. So this class REPLACES those three messages
+ * and adds none.
+ *
+ * The mechanism — replace rather than append, collapse the duplicate absence errors, match on
+ * emptiness rather than on MJ's wording — lives in `required-field-prose.ts`, shared with provisions.
+ *
+ * @module @mj-biz-apps/contracts-entities
+ */
+import { ValidationResult } from '@memberjunction/core';
+import { mjBizAppsContractsContractTemplateModificationEntity } from './generated/entity_subclasses.js';
+/**
+ * The prose each required field gets instead of "<Display Name> cannot be null".
+ *
+ * Each one says what to do, not what is wrong. `ContractID` is the odd member and is included
+ * deliberately: a user never sets it — MJ stamps it from the parent before validating
+ * (`relatedRecordCollection.ts`, `stampParentKey()` ahead of the child's `Validate()`), so inside the
+ * modification editor it cannot be empty. It can only be empty on the standalone form or an API
+ * call, which is precisely where "Contract cannot be null" is least useful, because the caller has to
+ * be told that a modification is meaningless without the contract it belongs to.
+ */
+export declare const MODIFICATION_REQUIRED_FIELD_PROSE: Readonly<Record<string, string>>;
+export declare class ContractTemplateModificationEntity extends mjBizAppsContractsContractTemplateModificationEntity {
+    Validate(): ValidationResult;
+}
+/**
+ * Anti-tree-shake anchor. Importing this module is what fires `@RegisterClass`; a production build can
+ * drop an import whose class is never referenced, and a dropped registration would silently restore
+ * MJ's flat messages with nothing failing — the same reason `LoadContractEntity` exists.
+ */
+export declare function LoadContractTemplateModificationEntity(): void;
+//# sourceMappingURL=ContractTemplateModificationEntity.d.ts.map

package/dist/ContractTemplateModificationEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTemplateModificationEntity.d.ts","sourceRoot":"","sources":["../src/ContractTemplateModificationEntity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAc,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEpE,OAAO,EAAE,oDAAoD,EAAE,MAAM,+BAA+B,CAAC;AAGrG;;;;;;;;;GASG;AACH,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAW9E,CAAC;AAEF,qBACa,kCAAmC,SAAQ,oDAAoD;IACxF,QAAQ,IAAI,gBAAgB;CAK/C;AAED;;;;GAIG;AACH,wBAAgB,sCAAsC,IAAI,IAAI,CAE7D"}

package/dist/ContractTemplateModificationEntity.js

@@ -0,0 +1,72 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * @fileoverview `ContractTemplateModificationEntity` — the SHARED subclass, and it exists for exactly
+ * one reason: the three fields a modification cannot do without refuse in prose nobody can act on.
+ *
+ * IT ADDS NO RULE. That distinction is the whole design, and getting it wrong here is a known trap
+ * (R-2 of `plans/backend-requirements.md`, withdrawn because implementing it would have produced a
+ * second copy of four working generated rules). `ContractID`, `ContractTemplateProvisionID` and — as
+ * of V202608192340 — `ModificationText` are all NOT NULL in the database, so MJ's own
+ * `EntityField.Validate()` already refuses an empty one and already names the field. The rule is the
+ * metadata; restating it in TypeScript would give one fact two owners and let them drift the next
+ * time a column's nullability changes.
+ *
+ * What MJ cannot know is what the user should DO about it. Its message is
+ * `` `${DisplayNameOrName} cannot be null` `` (`baseEntity.ts:320`) — correct, field-named, and mute
+ * on the only question the person in front of the form is asking. "Contract Template Provision
+ * cannot be null" does not tell anyone to pick a clause. So this class REPLACES those three messages
+ * and adds none.
+ *
+ * The mechanism — replace rather than append, collapse the duplicate absence errors, match on
+ * emptiness rather than on MJ's wording — lives in `required-field-prose.ts`, shared with provisions.
+ *
+ * @module @mj-biz-apps/contracts-entities
+ */
+import { BaseEntity } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import { mjBizAppsContractsContractTemplateModificationEntity } from './generated/entity_subclasses.js';
+import { ExplainMissingRequiredFields } from './required-field-prose.js';
+/**
+ * The prose each required field gets instead of "<Display Name> cannot be null".
+ *
+ * Each one says what to do, not what is wrong. `ContractID` is the odd member and is included
+ * deliberately: a user never sets it — MJ stamps it from the parent before validating
+ * (`relatedRecordCollection.ts`, `stampParentKey()` ahead of the child's `Validate()`), so inside the
+ * modification editor it cannot be empty. It can only be empty on the standalone form or an API
+ * call, which is precisely where "Contract cannot be null" is least useful, because the caller has to
+ * be told that a modification is meaningless without the contract it belongs to.
+ */
+export const MODIFICATION_REQUIRED_FIELD_PROSE = {
+    ContractID: 'A modification records what one specific contract negotiated, so it cannot exist on its own — ' +
+        'choose the contract this deviation belongs to.',
+    ContractTemplateProvisionID: 'Choose the standard provision this modification changes. The negotiated wording is only ' +
+        'meaningful beside the clause it replaces.',
+    ModificationText: 'Record what this contract says instead of the standard clause. A modification that does not ' +
+        'say what was agreed asserts that the paper differs without saying how, which is the one ' +
+        'state this record cannot usefully be in.',
+};
+let ContractTemplateModificationEntity = class ContractTemplateModificationEntity extends mjBizAppsContractsContractTemplateModificationEntity {
+    Validate() {
+        const result = super.Validate();
+        ExplainMissingRequiredFields(this, result, MODIFICATION_REQUIRED_FIELD_PROSE);
+        return result;
+    }
+};
+ContractTemplateModificationEntity = __decorate([
+    RegisterClass(BaseEntity, 'MJ_BizApps_Contracts: Contract Template Modifications')
+], ContractTemplateModificationEntity);
+export { ContractTemplateModificationEntity };
+/**
+ * Anti-tree-shake anchor. Importing this module is what fires `@RegisterClass`; a production build can
+ * drop an import whose class is never referenced, and a dropped registration would silently restore
+ * MJ's flat messages with nothing failing — the same reason `LoadContractEntity` exists.
+ */
+export function LoadContractTemplateModificationEntity() {
+    void ContractTemplateModificationEntity;
+}
+//# sourceMappingURL=ContractTemplateModificationEntity.js.map

package/dist/ContractTemplateModificationEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTemplateModificationEntity.js","sourceRoot":"","sources":["../src/ContractTemplateModificationEntity.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,UAAU,EAAoB,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,oDAAoD,EAAE,MAAM,+BAA+B,CAAC;AACrG,OAAO,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAEtE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAqC;IAC/E,UAAU,EACN,gGAAgG;QAChG,gDAAgD;IACpD,2BAA2B,EACvB,0FAA0F;QAC1F,2CAA2C;IAC/C,gBAAgB,EACZ,8FAA8F;QAC9F,0FAA0F;QAC1F,0CAA0C;CACjD,CAAC;AAGK,IAAM,kCAAkC,GAAxC,MAAM,kCAAmC,SAAQ,oDAAoD;IACxF,QAAQ;QACpB,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;QAChC,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,iCAAiC,CAAC,CAAC;QAC9E,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ,CAAA;AANY,kCAAkC;IAD9C,aAAa,CAAC,UAAU,EAAE,uDAAuD,CAAC;GACtE,kCAAkC,CAM9C;;AAED;;;;GAIG;AACH,MAAM,UAAU,sCAAsC;IAClD,KAAK,kCAAkC,CAAC;AAC5C,CAAC"}

package/dist/ContractTemplateProvisionEntity.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview `ContractTemplateProvisionEntity` — the SHARED subclass, and like the modification's
+ * it exists for one reason: the fields a provision cannot do without refuse in prose nobody can act on.
+ *
+ * IT ADDS NO RULE. `ContractTemplateID`, `ProvisionNumber`, `Title` and — as of V202608200800 —
+ * `ProvisionText` are all required at the database, the last two of them via
+ * `CK_ContractTemplateProvision_TextNotBlank` on top of `NOT NULL` (because `NOT NULL` accepts `''`;
+ * see the migration). MJ and CodeGen already refuse an empty one and already name the field. Only the
+ * sentence changes here.
+ *
+ * WHY `ProvisionText` MATTERS MORE THAN IT LOOKS. A provision is the STANDARD wording of a clause, and
+ * a `ContractTemplateModification` is only meaningful read as a PAIR against it — a dispute needs the
+ * comparison, not either half. A provision with no text is therefore worse than a modification with
+ * no text: every modification pointing at it inherits the gap, and the contract still renders.
+ *
+ * SERVER RULES ARE NOT HERE. Provision immutability once a contract references the template (R-1) and
+ * the delete guards (R-8) need cross-entity reads, so they live on
+ * `ContractTemplateProvisionEntityServer`. What is here is what a browser can preflight.
+ *
+ * @module @mj-biz-apps/contracts-entities
+ */
+import { ValidationResult } from '@memberjunction/core';
+import { mjBizAppsContractsContractTemplateProvisionEntity } from './generated/entity_subclasses.js';
+/**
+ * The prose each required field gets instead of "<Display Name> cannot be null".
+ *
+ * `ContractTemplateID` is included for the same reason `ContractID` is on the modification: a user
+ * never sets it inside the template form — MJ stamps it from the parent before validating — so it can
+ * only be empty on the standalone form or an API call, which is exactly where the flat message helps
+ * least.
+ *
+ * `ProvisionSortKey` is deliberately ABSENT. It is a persisted computed column and read-only, so it
+ * cannot be missing and cannot be set; naming it here would describe a failure that cannot happen.
+ */
+export declare const PROVISION_REQUIRED_FIELD_PROSE: Readonly<Record<string, string>>;
+export declare class ContractTemplateProvisionEntity extends mjBizAppsContractsContractTemplateProvisionEntity {
+    Validate(): ValidationResult;
+}
+/**
+ * Anti-tree-shake anchor. Importing this module is what fires `@RegisterClass`; a production build can
+ * drop an import whose class is never referenced, and a dropped registration would silently restore
+ * MJ's flat messages with nothing failing.
+ */
+export declare function LoadContractTemplateProvisionEntity(): void;
+//# sourceMappingURL=ContractTemplateProvisionEntity.d.ts.map

package/dist/ContractTemplateProvisionEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTemplateProvisionEntity.d.ts","sourceRoot":"","sources":["../src/ContractTemplateProvisionEntity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAc,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEpE,OAAO,EAAE,iDAAiD,EAAE,MAAM,+BAA+B,CAAC;AAGlG;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAc3E,CAAC;AAEF,qBACa,+BAAgC,SAAQ,iDAAiD;IAClF,QAAQ,IAAI,gBAAgB;CAK/C;AAED;;;;GAIG;AACH,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D"}

package/dist/ContractTemplateProvisionEntity.js

@@ -0,0 +1,73 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * @fileoverview `ContractTemplateProvisionEntity` — the SHARED subclass, and like the modification's
+ * it exists for one reason: the fields a provision cannot do without refuse in prose nobody can act on.
+ *
+ * IT ADDS NO RULE. `ContractTemplateID`, `ProvisionNumber`, `Title` and — as of V202608200800 —
+ * `ProvisionText` are all required at the database, the last two of them via
+ * `CK_ContractTemplateProvision_TextNotBlank` on top of `NOT NULL` (because `NOT NULL` accepts `''`;
+ * see the migration). MJ and CodeGen already refuse an empty one and already name the field. Only the
+ * sentence changes here.
+ *
+ * WHY `ProvisionText` MATTERS MORE THAN IT LOOKS. A provision is the STANDARD wording of a clause, and
+ * a `ContractTemplateModification` is only meaningful read as a PAIR against it — a dispute needs the
+ * comparison, not either half. A provision with no text is therefore worse than a modification with
+ * no text: every modification pointing at it inherits the gap, and the contract still renders.
+ *
+ * SERVER RULES ARE NOT HERE. Provision immutability once a contract references the template (R-1) and
+ * the delete guards (R-8) need cross-entity reads, so they live on
+ * `ContractTemplateProvisionEntityServer`. What is here is what a browser can preflight.
+ *
+ * @module @mj-biz-apps/contracts-entities
+ */
+import { BaseEntity } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import { mjBizAppsContractsContractTemplateProvisionEntity } from './generated/entity_subclasses.js';
+import { ExplainMissingRequiredFields } from './required-field-prose.js';
+/**
+ * The prose each required field gets instead of "<Display Name> cannot be null".
+ *
+ * `ContractTemplateID` is included for the same reason `ContractID` is on the modification: a user
+ * never sets it inside the template form — MJ stamps it from the parent before validating — so it can
+ * only be empty on the standalone form or an API call, which is exactly where the flat message helps
+ * least.
+ *
+ * `ProvisionSortKey` is deliberately ABSENT. It is a persisted computed column and read-only, so it
+ * cannot be missing and cannot be set; naming it here would describe a failure that cannot happen.
+ */
+export const PROVISION_REQUIRED_FIELD_PROSE = {
+    ContractTemplateID: 'A provision is a clause OF an agreement version, so it cannot stand alone — choose the ' +
+        'template this clause belongs to.',
+    ProvisionNumber: 'Give the clause its number as the document states it (for example 1.1, or 2.1A). The number is ' +
+        'also what orders the provisions, so a clause without one sorts to the top until it has one.',
+    Title: 'Give the clause a heading, as the document states it. It is what the contract screens show ' +
+        'when the full text is collapsed.',
+    ProvisionText: 'Record the standard wording of this clause. A provision with no text leaves every modification ' +
+        'that negotiates it comparing against nothing, and the pair — standard beside negotiated — is ' +
+        'what a dispute actually needs.',
+};
+let ContractTemplateProvisionEntity = class ContractTemplateProvisionEntity extends mjBizAppsContractsContractTemplateProvisionEntity {
+    Validate() {
+        const result = super.Validate();
+        ExplainMissingRequiredFields(this, result, PROVISION_REQUIRED_FIELD_PROSE);
+        return result;
+    }
+};
+ContractTemplateProvisionEntity = __decorate([
+    RegisterClass(BaseEntity, 'MJ_BizApps_Contracts: Contract Template Provisions')
+], ContractTemplateProvisionEntity);
+export { ContractTemplateProvisionEntity };
+/**
+ * Anti-tree-shake anchor. Importing this module is what fires `@RegisterClass`; a production build can
+ * drop an import whose class is never referenced, and a dropped registration would silently restore
+ * MJ's flat messages with nothing failing.
+ */
+export function LoadContractTemplateProvisionEntity() {
+    void ContractTemplateProvisionEntity;
+}
+//# sourceMappingURL=ContractTemplateProvisionEntity.js.map

package/dist/ContractTemplateProvisionEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTemplateProvisionEntity.js","sourceRoot":"","sources":["../src/ContractTemplateProvisionEntity.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,UAAU,EAAoB,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,iDAAiD,EAAE,MAAM,+BAA+B,CAAC;AAClG,OAAO,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAqC;IAC5E,kBAAkB,EACd,yFAAyF;QACzF,kCAAkC;IACtC,eAAe,EACX,iGAAiG;QACjG,6FAA6F;IACjG,KAAK,EACD,6FAA6F;QAC7F,kCAAkC;IACtC,aAAa,EACT,iGAAiG;QACjG,+FAA+F;QAC/F,gCAAgC;CACvC,CAAC;AAGK,IAAM,+BAA+B,GAArC,MAAM,+BAAgC,SAAQ,iDAAiD;IAClF,QAAQ;QACpB,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;QAChC,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,8BAA8B,CAAC,CAAC;QAC3E,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ,CAAA;AANY,+BAA+B;IAD3C,aAAa,CAAC,UAAU,EAAE,oDAAoD,CAAC;GACnE,+BAA+B,CAM3C;;AAED;;;;GAIG;AACH,MAAM,UAAU,mCAAmC;IAC/C,KAAK,+BAA+B,CAAC;AACzC,CAAC"}

package/dist/ContractTypeEntity.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview `ContractTypeEntity` and `ContractTemplateTypeEntity` — the two lookup tables, which
+ * exist as subclasses for exactly one reason: their value-list columns are validated NOWHERE.
+ *
+ * Both carry an `nvarchar` column constrained by `CHECK (… IN (…))` — `ContractType.Status` and
+ * `ContractTemplateType.Status`. (A third, `ContractType.ParentStatusRequirement`, was the original
+ * motivating case; R-4 replaced it with two booleans, which need no value list at all — a `bit` has
+ * only two possible values. The guard stays generic, so losing a field does not change it.) CodeGen
+ * renders that kind of
+ * constraint as value-list METADATA rather than as a generated `Validate()` method, and `BaseEntity`
+ * never reads value-list metadata, so the constraint has no TypeScript representation at all. Full
+ * reasoning, and the deletion plan, in `value-list-validation.ts`; filed as MJ#3969.
+ *
+ * These are the app's only entities with value-list fields today. `ValidateValueLists` is generic
+ * rather than field-specific, so a future one is covered by adding the call, not by writing a check.
+ *
+ * WHY THESE TWO AND NOT ALL FIVE UNSUBCLASSED ENTITIES. `ContractTemplate` and
+ * `ContractTemplateProvision` also lack subclasses, and both will need one — for provision
+ * immutability (R-1) and the `ProvisionNumber` sort key (R-11). Neither rule is decided yet, and a
+ * subclass created ahead of a rule is a file that says nothing while looking like it says something.
+ * They arrive with their rules. `ContractSequence` is a separate question (R-7): whether it should be
+ * an API-writable entity at all.
+ *
+ * @module @mj-biz-apps/contracts-entities
+ */
+import { ValidationResult } from '@memberjunction/core';
+import { mjBizAppsContractsContractTemplateTypeEntity, mjBizAppsContractsContractTypeEntity } from './generated/entity_subclasses.js';
+/**
+ * `Status` (`Active` / `Inactive`) — the only value-list column left on this table.
+ *
+ * It is load-bearing rather than cosmetic: R-5 refuses a contract that NEWLY selects a type whose
+ * `Status` is `Inactive`, and R-8 refuses deleting a type in use while telling the user to retire it
+ * instead. So "Active" / "Inactive" is the vocabulary two rules read, and the database's `CHECK` is
+ * what keeps a third string out of the column — but it refuses at the very end, as a constraint
+ * violation naming no field. This makes the refusal arrive on the field, in the browser, before the
+ * round trip.
+ *
+ * The type's three RULE columns (`MustBeRoot`, `MustBeChild`, `TemplateRequired`) are `bit`s and need
+ * nothing here — a boolean cannot hold an out-of-list value, which is half the argument R-4 made for
+ * replacing the three-state string.
+ */
+export declare class ContractTypeEntity extends mjBizAppsContractsContractTypeEntity {
+    Validate(): ValidationResult;
+}
+/** `Status` (`Active` / `Inactive`) — see the note above. */
+export declare class ContractTemplateTypeEntity extends mjBizAppsContractsContractTemplateTypeEntity {
+    Validate(): ValidationResult;
+}
+/**
+ * Anti-tree-shake anchor. Importing this module is what fires `@RegisterClass`; a production build can
+ * drop an import whose class is never referenced, and a dropped registration means the rules above
+ * silently stop existing — the same reason `LoadContractEntity` exists.
+ */
+export declare function LoadContractTypeEntities(): void;
+//# sourceMappingURL=ContractTypeEntity.d.ts.map

package/dist/ContractTypeEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTypeEntity.d.ts","sourceRoot":"","sources":["../src/ContractTypeEntity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAc,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEpE,OAAO,EACH,4CAA4C,EAC5C,oCAAoC,EACvC,MAAM,+BAA+B,CAAC;AAGvC;;;;;;;;;;;;;GAaG;AACH,qBACa,kBAAmB,SAAQ,oCAAoC;IACxD,QAAQ,IAAI,gBAAgB;CAK/C;AAED,6DAA6D;AAC7D,qBACa,0BAA2B,SAAQ,4CAA4C;IACxE,QAAQ,IAAI,gBAAgB;CAK/C;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAG/C"}

package/dist/ContractTypeEntity.js

@@ -0,0 +1,82 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * @fileoverview `ContractTypeEntity` and `ContractTemplateTypeEntity` — the two lookup tables, which
+ * exist as subclasses for exactly one reason: their value-list columns are validated NOWHERE.
+ *
+ * Both carry an `nvarchar` column constrained by `CHECK (… IN (…))` — `ContractType.Status` and
+ * `ContractTemplateType.Status`. (A third, `ContractType.ParentStatusRequirement`, was the original
+ * motivating case; R-4 replaced it with two booleans, which need no value list at all — a `bit` has
+ * only two possible values. The guard stays generic, so losing a field does not change it.) CodeGen
+ * renders that kind of
+ * constraint as value-list METADATA rather than as a generated `Validate()` method, and `BaseEntity`
+ * never reads value-list metadata, so the constraint has no TypeScript representation at all. Full
+ * reasoning, and the deletion plan, in `value-list-validation.ts`; filed as MJ#3969.
+ *
+ * These are the app's only entities with value-list fields today. `ValidateValueLists` is generic
+ * rather than field-specific, so a future one is covered by adding the call, not by writing a check.
+ *
+ * WHY THESE TWO AND NOT ALL FIVE UNSUBCLASSED ENTITIES. `ContractTemplate` and
+ * `ContractTemplateProvision` also lack subclasses, and both will need one — for provision
+ * immutability (R-1) and the `ProvisionNumber` sort key (R-11). Neither rule is decided yet, and a
+ * subclass created ahead of a rule is a file that says nothing while looking like it says something.
+ * They arrive with their rules. `ContractSequence` is a separate question (R-7): whether it should be
+ * an API-writable entity at all.
+ *
+ * @module @mj-biz-apps/contracts-entities
+ */
+import { BaseEntity } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import { mjBizAppsContractsContractTemplateTypeEntity, mjBizAppsContractsContractTypeEntity, } from './generated/entity_subclasses.js';
+import { ValidateValueLists } from './value-list-validation.js';
+/**
+ * `Status` (`Active` / `Inactive`) — the only value-list column left on this table.
+ *
+ * It is load-bearing rather than cosmetic: R-5 refuses a contract that NEWLY selects a type whose
+ * `Status` is `Inactive`, and R-8 refuses deleting a type in use while telling the user to retire it
+ * instead. So "Active" / "Inactive" is the vocabulary two rules read, and the database's `CHECK` is
+ * what keeps a third string out of the column — but it refuses at the very end, as a constraint
+ * violation naming no field. This makes the refusal arrive on the field, in the browser, before the
+ * round trip.
+ *
+ * The type's three RULE columns (`MustBeRoot`, `MustBeChild`, `TemplateRequired`) are `bit`s and need
+ * nothing here — a boolean cannot hold an out-of-list value, which is half the argument R-4 made for
+ * replacing the three-state string.
+ */
+let ContractTypeEntity = class ContractTypeEntity extends mjBizAppsContractsContractTypeEntity {
+    Validate() {
+        const result = super.Validate();
+        ValidateValueLists(this, result);
+        return result;
+    }
+};
+ContractTypeEntity = __decorate([
+    RegisterClass(BaseEntity, 'MJ_BizApps_Contracts: Contract Types')
+], ContractTypeEntity);
+export { ContractTypeEntity };
+/** `Status` (`Active` / `Inactive`) — see the note above. */
+let ContractTemplateTypeEntity = class ContractTemplateTypeEntity extends mjBizAppsContractsContractTemplateTypeEntity {
+    Validate() {
+        const result = super.Validate();
+        ValidateValueLists(this, result);
+        return result;
+    }
+};
+ContractTemplateTypeEntity = __decorate([
+    RegisterClass(BaseEntity, 'MJ_BizApps_Contracts: Contract Template Types')
+], ContractTemplateTypeEntity);
+export { ContractTemplateTypeEntity };
+/**
+ * Anti-tree-shake anchor. Importing this module is what fires `@RegisterClass`; a production build can
+ * drop an import whose class is never referenced, and a dropped registration means the rules above
+ * silently stop existing — the same reason `LoadContractEntity` exists.
+ */
+export function LoadContractTypeEntities() {
+    void ContractTypeEntity;
+    void ContractTemplateTypeEntity;
+}
+//# sourceMappingURL=ContractTypeEntity.js.map

package/dist/ContractTypeEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTypeEntity.js","sourceRoot":"","sources":["../src/ContractTypeEntity.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,UAAU,EAAoB,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EACH,4CAA4C,EAC5C,oCAAoC,GACvC,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;;;;;;;;;;;GAaG;AAEI,IAAM,kBAAkB,GAAxB,MAAM,kBAAmB,SAAQ,oCAAoC;IACxD,QAAQ;QACpB,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;QAChC,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACjC,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ,CAAA;AANY,kBAAkB;IAD9B,aAAa,CAAC,UAAU,EAAE,sCAAsC,CAAC;GACrD,kBAAkB,CAM9B;;AAED,6DAA6D;AAEtD,IAAM,0BAA0B,GAAhC,MAAM,0BAA2B,SAAQ,4CAA4C;IACxE,QAAQ;QACpB,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;QAChC,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACjC,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ,CAAA;AANY,0BAA0B;IADtC,aAAa,CAAC,UAAU,EAAE,+CAA+C,CAAC;GAC9D,0BAA0B,CAMtC;;AAED;;;;GAIG;AACH,MAAM,UAAU,wBAAwB;IACpC,KAAK,kBAAkB,CAAC;IACxB,KAAK,0BAA0B,CAAC;AACpC,CAAC"}

package/dist/contract-state.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview The contract lifecycle — the VALUES only. The rule itself lives in SQL.
+ *
+ * `State` is derived, not stored (D-19 / ERD R-18): four of the old `Status` column's five values
+ * were projections of the dates and the two self-FKs, and a stored copy of a projection can only
+ * agree or lie. It is derived in exactly ONE place — the `CASE` in the app-owned layered base view
+ * (`V202608182001`) — and application code READS `contract.State`. It does not re-derive it.
+ *
+ * WHY THIS FILE NO LONGER CARRIES THE RULE (Marcelo, 2026-08-19). It used to hold
+ * `DeriveContractState()` for TypeScript and `StateSQL()` to render the same rule as T-SQL, on the
+ * reasoning that one module rendering both copies could not drift. That reasoning was wrong, and it
+ * failed in the most direct way available: the TypeScript branch for termination was tightened to
+ * "terminated before today", the view was not, and for several hours the same contract read `Active`
+ * in the browser and `Terminated` from every view-backed query. The guard did not fire because it
+ * compared the two renderings as TEXT, and text cannot see a semantic split.
+ *
+ * The lesson is not "write a better guard" — a guard that has to be right about two implementations
+ * is a third thing to get wrong. It is: **do not mirror a rule.** One definition, in one language.
+ * SQL wins here because the rule is time-dependent (`Expired` and `Active` turn over at midnight with
+ * no write to trigger them), so it must be evaluated at READ time, which is what a view does and what
+ * no amount of TypeScript can do for a row nobody has loaded.
+ *
+ * WHAT THAT COSTS, stated plainly: the rule can no longer be tested without a database, so
+ * `npx vitest run` cannot cover its semantics. Two things stand in for it. `contract-state.test.ts`
+ * asserts the committed migration's `CASE` matches the branches and precedence THIS TEST declares —
+ * an expectation owned by the test, checked against the single implementation, so it is not two
+ * implementations agreeing with each other. And `test-harnesses/state-equivalence.mjs` runs fixtures
+ * covering every state and the termination boundary through the deployed view and asserts the answers
+ * a person wrote down.
+ *
+ * A contract being EDITED therefore shows its last-saved state, not a live projection of unsaved
+ * dates. That is deliberate: a chip reacting to an unsaved date asserts something no query would
+ * agree with.
+ *
+ * @module @mj-biz-apps/contracts-entities
+ */
+/**
+ * The six lifecycle states, in precedence order — first match wins (ERD §4.5).
+ *
+ * Kept in TypeScript because the CLIENT needs the vocabulary (chip colours, a filter pill, a typed
+ * `State` accessor) even though it does not own the rule. This is a value list, not a second
+ * implementation: nothing here decides which state a contract is in.
+ *
+ * The order is load-bearing documentation of the view's precedence, and
+ * `contract-state.test.ts` asserts the migration's `CASE` still matches it.
+ */
+export declare const CONTRACT_STATES: readonly ["Terminated", "Superseded", "Expired", "Active", "Executed", "Draft"];
+export type ContractState = (typeof CONTRACT_STATES)[number];
+//# sourceMappingURL=contract-state.d.ts.map

package/dist/contract-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-state.d.ts","sourceRoot":"","sources":["../src/contract-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,iFAAkF,CAAC;AAE/G,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC"}