@mj-biz-apps/orders-entities 0.0.1 → 5.2.0

package/LICENSE

@@ -0,0 +1,183 @@
+Business Source License 1.1
+
+License text copyright (c) 2024 MariaDB plc, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB plc.
+
+-----------------------------------------------------------------------------
+
+Parameters
+
+Licensor:             Blue Cypress, Inc.
+
+Licensed Work:        MemberJunction.
+                      The Licensed Work is (c) 2023-2026 Blue Cypress, Inc.
+
+Additional Use Grant: Subject to the terms of this License, Licensor grants
+                      you the following additional rights to make Production
+                      Use of the Licensed Work.
+
+                      1. Internal Use
+
+                      You may make production use of the Licensed Work for
+                      your own internal business or organizational operations.
+
+                      2. Nonprofit Use
+
+                      If you are a Nonprofit, you may make production use of
+                      the Licensed Work for the operations and activities of
+                      your Organizational Family.
+
+                      3. MemberJunction Certified Program Use
+
+                      If you are authorized by Licensor under the
+                      MemberJunction Certified Program to provide professional
+                      services using the Licensed Work, you may make
+                      production use of the Licensed Work in providing such
+                      professional services to a client, provided that:
+
+                      (a) the Licensed Work is deployed in, and the applicable
+                      production use occurs within, an environment owned,
+                      leased, licensed, subscribed to, or otherwise controlled
+                      by that client; and
+
+                      (b) the production use is for that client's own internal
+                      business or organizational operations or is otherwise
+                      independently permitted to that client under this
+                      Additional Use Grant.
+
+                      4. Definitions Applicable to the Additional Use Grant
+
+                      "Affiliate" means, with respect to a specified Person,
+                      any other Person that directly or indirectly Controls,
+                      is Controlled by, or is under common Control with such
+                      specified Person.
+
+                      "Control" (including the terms "Controls," "Controlled
+                      by," and "under common Control with") means the direct
+                      or indirect possession of the power to direct or cause
+                      the direction of the management and policies of a
+                      Person, whether through ownership of voting interests,
+                      by contract, or otherwise.
+
+                      "Organizational Family" means, with respect to a Person,
+                      (a) such Person and its Affiliates, and (b) any
+                      nonprofit organization, governmental entity, chapter,
+                      division, local affiliate, regional affiliate, state
+                      affiliate, national affiliate, or other entity that is
+                      formally affiliated with such Person through governing
+                      documents, a charter, bylaws, a membership agreement, or
+                      another written organizational instrument, and is
+                      recognized under such documents as part of the same
+                      organizational structure.
+
+                      "Nonprofit" means a Person recognized by the Internal
+                      Revenue Service as exempt from federal income taxation
+                      under Section 501(c)(3), 501(c)(4), 501(c)(5), or
+                      501(c)(6) of the Internal Revenue Code, or a foreign
+                      organization recognized under substantially equivalent
+                      laws.
+
+                      A Person claiming eligibility as a Nonprofit shall, upon
+                      Licensor's reasonable request, provide documentation
+                      reasonably sufficient to demonstrate that it qualifies
+                      as a Nonprofit. If such Person materially misrepresents,
+                      or is unable to demonstrate, its qualification as a
+                      Nonprofit, the rights granted to such Person under
+                      Section 2 of this Additional Use Grant shall terminate.
+
+                      "MemberJunction Certified Program" means Licensor's
+                      then-current program for certifying and authorizing a
+                      Person to provide professional services using the
+                      Licensed Work.
+
+                      "Person" means any individual, corporation, limited
+                      liability company, partnership, association, nonprofit
+                      organization, governmental entity, or other legal or
+                      organizational entity.
+
+Change Date:          Four (4) years from the date the Licensed Work is first
+                      made available.
+
+Change License:       MIT License.
+
+For information about alternative licensing arrangements for the Licensed
+Work, please contact Blue Cypress, Inc.
+
+-----------------------------------------------------------------------------
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+MariaDB hereby grants you permission to use this License's text to license
+your works, and to refer to it using the trademark "Business Source License",
+as long as you comply with the Covenants of Licensor below.
+
+-----------------------------------------------------------------------------
+
+Covenants of Licensor
+
+In consideration of the right to use this License's text and the "Business
+Source License" name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where "compatible" means that software provided under the Change License
+   can be included in a program with software provided under GPL Version 2.0
+   or a later version. Licensor may specify additional Change Licenses without
+   limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text "None".
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.
+
+-----------------------------------------------------------------------------
+
+Notice
+
+The Business Source License (this document, or the "License") is not an Open
+Source license. However, the Licensed Work will eventually be made available
+under an Open Source License, as stated in this License.

package/README.md

@@ -1,3 +1,51 @@
-# @mj-biz-apps/orders-entities
+# `@mj-biz-apps/orders-entities`
 
-Placeholder release. See https://github.com/MemberJunction/bizapps-orders
+**Generated entity subclasses and Zod schemas for every table in `__mj_BizAppsOrders`.** Browser-safe:
+depends on `@memberjunction/core` and `zod`, nothing server-side.
+
+## Do not edit anything in `src/generated/`
+
+CodeGen rewrites it wholesale from the database. Edits are lost at the next run, silently, and
+usually at the worst moment.
+
+To change what appears here, change the **schema**:
+
+```bash
+# 1. edit the baseline migration (pre-1.0 practice: edit in place, never fix-up migrations)
+# 2. rebuild from zero and regenerate
+scripts/rebuild-db.sh          # trims the generated half, applies hand-authored DDL only
+npm run mj:codegen             # regenerates everything, since the DB is now bare
+scripts/append-codegen.sh      # puts the generated SQL back below the banner
+npm run mj -- sync push --dir metadata
+```
+
+That cycle is self-consistent by construction: the rebuild deliberately drops the generated half
+first, because otherwise it produces a database whose metadata is already current and CodeGen emits
+only a delta.
+
+## What CodeGen gives you, and what it does not
+
+**Does:** a typed class per entity, a Zod schema per entity, string-union types derived from CHECK
+constraints (`OrderType`, `Status`, `PricingModel`…), and field descriptions lifted from the
+migration's `MS_Description` extended properties.
+
+That last one is why the migration is so heavily commented — those comments become the developer
+documentation and the AI-facing metadata. A column added without an extended property arrives here
+undocumented.
+
+**Does not:** business rules. Every invariant lives in
+`@mj-biz-apps/orders-core-entities-server`, whose subclasses override `Save()` and are resolved by
+`ClassFactory` at runtime. Instantiating an entity from this package on the client gets you the
+shape; the rules run on the server.
+
+## Two things that will bite
+
+**Union types come from CHECK constraints.** Widening a CHECK widens the type — a breaking change to
+consumers even though no TypeScript was touched. Narrowing one is worse: existing rows become
+unrepresentable.
+
+**A repeated column name inside a CHECK can break generation.** CodeGen derives validation method
+names from the constraint expression, and repeating a column produced a call to
+`ValidatePromotionOrReasonRequiredReasonRequiredReasonRequired` against a method defined as
+`ValidatePromotionOrReasonRequired` — a build break in generated code. Name the column once
+(`ISNULL(col, '')` rather than `col IS NOT NULL AND col <> ''`). Reported upstream.

package/dist/CustomerPaymentMethodEntity.d.ts

@@ -0,0 +1,4 @@
+import { mjBizAppsOrdersCustomerPaymentMethodEntity } from './generated/entity_subclasses.js';
+export declare class CustomerPaymentMethodEntity extends mjBizAppsOrdersCustomerPaymentMethodEntity {
+}
+//# sourceMappingURL=CustomerPaymentMethodEntity.d.ts.map

package/dist/CustomerPaymentMethodEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomerPaymentMethodEntity.d.ts","sourceRoot":"","sources":["../src/CustomerPaymentMethodEntity.ts"],"names":[],"mappings":"AAUA,OAAO,EACH,0CAA0C,EAE7C,MAAM,+BAA+B,CAAC;AAKvC,qBACa,2BAA4B,SAAQ,0CAA0C;CAAG"}

package/dist/CustomerPaymentMethodEntity.js

@@ -0,0 +1,26 @@
+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;
+};
+/**
+ * Shared (client + server) subclass for Customer Payment Methods.
+ *
+ * Declares the required `PaymentDetailID` embed here — the wallet is a thin host
+ * and the instrument snapshot lives on Payment Details (D38/D39). CodeGen will
+ * emit the same members onto the generated class once `EntityField.EmbeddedRecord`
+ * is set on a database that has that MJ column; remove this declaration then.
+ */
+import { BaseEntity } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import { mjBizAppsOrdersCustomerPaymentMethodEntity, } from './generated/entity_subclasses.js';
+const ENTITY = 'MJ_BizApps_Orders: Customer Payment Methods';
+const DETAIL_ENTITY = 'MJ_BizApps_Orders: Payment Details';
+let CustomerPaymentMethodEntity = class CustomerPaymentMethodEntity extends mjBizAppsOrdersCustomerPaymentMethodEntity {
+};
+CustomerPaymentMethodEntity = __decorate([
+    RegisterClass(BaseEntity, ENTITY)
+], CustomerPaymentMethodEntity);
+export { CustomerPaymentMethodEntity };
+//# sourceMappingURL=CustomerPaymentMethodEntity.js.map

package/dist/CustomerPaymentMethodEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomerPaymentMethodEntity.js","sourceRoot":"","sources":["../src/CustomerPaymentMethodEntity.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EACH,0CAA0C,GAE7C,MAAM,+BAA+B,CAAC;AAEvC,MAAM,MAAM,GAAG,6CAA6C,CAAC;AAC7D,MAAM,aAAa,GAAG,oCAAoC,CAAC;AAGpD,IAAM,2BAA2B,GAAjC,MAAM,2BAA4B,SAAQ,0CAA0C;CAAG,CAAA;AAAjF,2BAA2B;IADvC,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC;GACrB,2BAA2B,CAAsD"}

package/dist/InitialPaymentIntentCompanion.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The check / wire / transfer number typed at order entry.
+ *
+ * There is no `InitialPaymentReference` column — the number lives on `PaymentDetail.ReferenceNumber`
+ * once confirm creates that row. Until then the browser holds a string that has to reach the
+ * server, which is what a companion is for (same reason as promotion codes).
+ *
+ * Leaving it as page state is how Fast Entry confirmed a Check with "abc" on screen and the
+ * server refused: `createInitialPayment` only looks at `InitialPaymentDetailID`, and nothing had
+ * created that row.
+ */
+import { EntityCompanion, type EntityCompanionDeserializeMode } from '@memberjunction/core';
+export type InitialPaymentIntentWire = {
+    Reference: string;
+};
+export declare class InitialPaymentIntentCompanion extends EntityCompanion<InitialPaymentIntentWire> {
+    readonly Name = "InitialPaymentIntent";
+    private reference;
+    get Reference(): string | null;
+    set Reference(value: string | null);
+    Serialize(): Promise<InitialPaymentIntentWire | null>;
+    Deserialize(data: InitialPaymentIntentWire, _mode: EntityCompanionDeserializeMode): Promise<void>;
+    /**
+     * Dirty when a reference is present so a confirm whose only extra fact is the check
+     * number still ships the companion. A clean companion would drop it on Save().
+     */
+    get Dirty(): boolean;
+}
+//# sourceMappingURL=InitialPaymentIntentCompanion.d.ts.map

package/dist/InitialPaymentIntentCompanion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitialPaymentIntentCompanion.d.ts","sourceRoot":"","sources":["../src/InitialPaymentIntentCompanion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,eAAe,EAAE,KAAK,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAE5F,MAAM,MAAM,wBAAwB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7D,qBAAa,6BAA8B,SAAQ,eAAe,CAAC,wBAAwB,CAAC;IACxF,SAAgB,IAAI,0BAA0B;IAE9C,OAAO,CAAC,SAAS,CAAuB;IAExC,IAAW,SAAS,IAAI,MAAM,GAAG,IAAI,CAEpC;IAED,IAAW,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAGxC;IAEY,SAAS,IAAI,OAAO,CAAC,wBAAwB,GAAG,IAAI,CAAC;IAIrD,WAAW,CACpB,IAAI,EAAE,wBAAwB,EAC9B,KAAK,EAAE,8BAA8B,GACtC,OAAO,CAAC,IAAI,CAAC;IAIhB;;;OAGG;IACH,IAAoB,KAAK,IAAI,OAAO,CAEnC;CACJ"}

package/dist/InitialPaymentIntentCompanion.js

@@ -0,0 +1,40 @@
+/**
+ * The check / wire / transfer number typed at order entry.
+ *
+ * There is no `InitialPaymentReference` column — the number lives on `PaymentDetail.ReferenceNumber`
+ * once confirm creates that row. Until then the browser holds a string that has to reach the
+ * server, which is what a companion is for (same reason as promotion codes).
+ *
+ * Leaving it as page state is how Fast Entry confirmed a Check with "abc" on screen and the
+ * server refused: `createInitialPayment` only looks at `InitialPaymentDetailID`, and nothing had
+ * created that row.
+ */
+import { EntityCompanion } from '@memberjunction/core';
+export class InitialPaymentIntentCompanion extends EntityCompanion {
+    constructor() {
+        super(...arguments);
+        this.Name = 'InitialPaymentIntent';
+        this.reference = null;
+    }
+    get Reference() {
+        return this.reference;
+    }
+    set Reference(value) {
+        const trimmed = (value ?? '').trim();
+        this.reference = trimmed.length ? trimmed : null;
+    }
+    async Serialize() {
+        return this.reference ? { Reference: this.reference } : null;
+    }
+    async Deserialize(data, _mode) {
+        this.Reference = data?.Reference ?? null;
+    }
+    /**
+     * Dirty when a reference is present so a confirm whose only extra fact is the check
+     * number still ships the companion. A clean companion would drop it on Save().
+     */
+    get Dirty() {
+        return this.reference != null;
+    }
+}
+//# sourceMappingURL=InitialPaymentIntentCompanion.js.map

package/dist/InitialPaymentIntentCompanion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitialPaymentIntentCompanion.js","sourceRoot":"","sources":["../src/InitialPaymentIntentCompanion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,eAAe,EAAuC,MAAM,sBAAsB,CAAC;AAI5F,MAAM,OAAO,6BAA8B,SAAQ,eAAyC;IAA5F;;QACoB,SAAI,GAAG,sBAAsB,CAAC;QAEtC,cAAS,GAAkB,IAAI,CAAC;IA6B5C,CAAC;IA3BG,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,IAAW,SAAS,CAAC,KAAoB;QACrC,MAAM,OAAO,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QACrC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;IACrD,CAAC;IAEM,KAAK,CAAC,SAAS;QAClB,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IACjE,CAAC;IAEM,KAAK,CAAC,WAAW,CACpB,IAA8B,EAC9B,KAAqC;QAErC,IAAI,CAAC,SAAS,GAAG,IAAI,EAAE,SAAS,IAAI,IAAI,CAAC;IAC7C,CAAC;IAED;;;OAGG;IACH,IAAoB,KAAK;QACrB,OAAO,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC;IAClC,CAAC;CACJ"}

package/dist/OrderHeaderEntity.d.ts

@@ -0,0 +1,224 @@
+/**
+ * @fileoverview `OrderHeaderEntity` — the order rules that hold on BOTH tiers.
+ *
+ * WHY THIS LAYER EXISTS
+ *
+ * Every order rule used to live in `OrderEntityServer`, in a server-only package. That meant the
+ * browser could compose an order that the server would refuse, and only find out after a round
+ * trip — and it meant a rule enforced "in the order screen" was enforced nowhere at all the moment
+ * anything else saved an order. This codebase has found that shape three times.
+ *
+ * So the rules split by what they NEED, not by where they were written:
+ *
+ *   · Here — anything decidable from the record and its lines alone. No database, no engine, no
+ *     provider. Runs in the browser before a round trip and again on the server, because the server
+ *     subclass extends this one and `super.Validate()` still fires.
+ *   · `OrderEntityServer` — anything that must read or write the database: pricing, promotions,
+ *     charges and tax, journal entries, subscriptions, sequence numbers.
+ *
+ * `ClassFactory` priority auto-increments by load order, so the server subclass — registered later
+ * because it is loaded later — wins server-side with no configuration, while the browser resolves
+ * to this one and keeps the `Lines` collection the generated class declares.
+ *
+ * WHAT THIS DELIBERATELY DOES NOT DO
+ *
+ * It does not override `Save()`. A shared class that persisted would have to work on a provider
+ * that cannot open a transaction, which is exactly the split that made composite saves server-only
+ * before MJ 6.1. Persistence stays with the server subclass; the browser ships the whole graph in
+ * one `MJ.SaveEntityGraph` call and the server runs the same executor.
+ *
+ * @module @mj-biz-apps/orders-entities
+ */
+import { ValidationResult, type FieldValueCollection } from '@memberjunction/core';
+import { mjBizAppsOrdersOrderHeaderEntity } from './generated/entity_subclasses.js';
+import { type TransitionVerdict } from './OrderStatusBehavior.js';
+import { PromotionCodesCompanion } from './PromotionCodesCompanion.js';
+import { InitialPaymentIntentCompanion } from './InitialPaymentIntentCompanion.js';
+/** The order editor's sections, in the order the screen shows them. */
+export type OrderEditorSection = 'header' | 'parties' | 'lines' | 'charges' | 'payment';
+export declare class OrderHeaderEntity extends mjBizAppsOrdersOrderHeaderEntity {
+    /**
+     * Promotion codes the customer presented, riding with the order across the wire.
+     *
+     * Registered HERE rather than on the server subclass so a browser has it: the whole point is
+     * that a code typed on screen reaches the engine. See `PromotionCodesCompanion` for why this is
+     * a companion and not a related-record collection — in short, a code has no child row, and only
+     * the engine can turn one into an `OrderAdjustment`.
+     */
+    readonly PromotionCodes: PromotionCodesCompanion;
+    /**
+     * Check / wire / transfer number typed at entry. Not a column — it rides as a companion
+     * and `OrderEntityServer.createInitialPayment` turns it into a `PaymentDetail`.
+     */
+    readonly InitialPaymentIntent: InitialPaymentIntentCompanion;
+    ClearInitialPaymentDetail(): void;
+    ClearBillToAddress(): void;
+    ClearShipToAddress(): void;
+    get InitialPaymentReference(): string | null;
+    set InitialPaymentReference(value: string | null);
+    private isInitialPaymentDetailEmpty;
+    /**
+     * True while THIS save is the booking save, and it stays true across `ConfirmedAt` being set.
+     *
+     * `willBookOnThisSave()` answers "would a save starting now book?", which is the right question
+     * everywhere except inside the booking save itself. The server subclass stamps `ConfirmedAt`
+     * before it calls `super.Save()`, and `ConfirmedAt` is exactly what makes `willBookOnThisSave()`
+     * return false — so validation running inside that `super.Save()` was asking a question whose
+     * answer had already been flipped by its own caller, three lines earlier. Every rule gated on it
+     * was therefore skipped on the one save it existed to guard.
+     *
+     * That is why a confirm with zero lines (ORD-000030) and a confirm with no payer (ORD-000028,
+     * which posted Dr A/R 99 / Cr Sales 99) both went through. Two separate defects had to coincide
+     * — this one and a skipped `ValidateAsync` — and fixing either alone changes nothing, which is
+     * why the block looked correct for as long as it did.
+     *
+     * `protected` because the server subclass sets it around its booking walk.
+     */
+    protected bookingInFlight: boolean;
+    /** True when this save is the first transition into a booked status (plan D8). */
+    protected willBookOnThisSave(): boolean;
+    /**
+     * Whether the status change on this save is a legal move.
+     *
+     * The PERSISTED status is the `from`: `OldValue` is what is on disk, so re-saving an unchanged
+     * row is a no-op transition and a genuine move is measured against what was really there rather
+     * than against whatever this object was last set to.
+     *
+     * `CK_OrderHeader_Status` enforces the legal SET of statuses and nothing enforced the legal
+     * MOVES, which is how `Voided → Confirmed` used to save: a voided order came back to life
+     * keeping the journal entries its reversal had already unwound.
+     */
+    /**
+     * The lifecycle verdict on this save's status change, with no side effects.
+     *
+     * Separate from `Validate()` because the server subclass has to ask this question EARLY —
+     * before it prices lines, mints an order number or posts anything — while the rest of
+     * `Validate()` cannot be asked that early: it includes the generated NOT NULL field checks, and
+     * `OrderNumber`, `Company` and each line's `UnitPrice` are all populated by the save itself.
+     * Running the whole of `Validate()` up front therefore fails on fields the save was about to
+     * fill in.
+     */
+    protected statusTransitionVerdict(): TransitionVerdict;
+    /** The refusal message for an illegal move, shared by `Validate()` and the server's early gate. */
+    protected statusTransitionRefusal(verdict: TransitionVerdict): string;
+    /**
+     * Rules decidable without touching the database.
+     *
+     * `super.Validate()` fans out to every declared related-record collection, so each line's own
+     * `Validate()` runs here too and its failures arrive attributed by position (`Lines[3].Quantity`).
+     * That replaces a hand-written loop that only existed on the server.
+     */
+    NewRecord(newValues?: FieldValueCollection): boolean;
+    Validate(): ValidationResult;
+    /**
+     * `super.Validate()` includes generated NOT NULL checks for fields this save
+     * is about to fill in (`OrderNumber`, each new line's `UnitPrice` / `CompanyID`
+     * / `LineNumber`). Fast Entry and the editor gate confirm on `Validate()`, so
+     * those checks disabled the button on every complete unsaved order.
+     *
+     * Same reason `OrderEntityServer.Save()` refuses to run the full `Validate()`
+     * before it mints the number. After the first save the values exist, so an
+     * empty one is a real error and is kept.
+     */
+    private dropSavePopulatedFieldErrors;
+    /** Whether this order is booked to the ledger right now. */
+    get IsBookedOrder(): boolean;
+    /**
+     * True when money composition is frozen: the order was already booked
+     * *before* this save. The booking save itself (Draft/Quoted → Confirmed)
+     * must still write the figures it just computed. A brand-new unsaved row
+     * is never locked, including back-office create-as-Confirmed.
+     */
+    get MoneyLocked(): boolean;
+    /**
+     * Refuse adds / removes / reprices / tender restatements after booking.
+     * The booking save itself still has to write the figures it just computed.
+     */
+    private refuseBookedMoneyEdits;
+    /**
+     * Which editing SECTION each validation failure belongs to.
+     *
+     * The order editor shows errors against the section that owns the field — an unreachable payer
+     * lights up "parties", a bad quantity lights up "lines" — so the user is stopped at the field
+     * they can fix rather than at a rejection after the fact.
+     *
+     * This lives on the shared subclass because it is metadata-only: it reads the `Source` a
+     * `ValidationErrorInfo` already carries and maps it to a section. No database, no provider, so
+     * the browser gets it for free and the server does not need it at all.
+     *
+     * It replaces `OrderDraft.SectionsWithErrors`, which computed the same thing from a parallel
+     * model of the order that had to be kept in step with the entity by hand.
+     */
+    static SectionForField(source: string | null | undefined): OrderEditorSection;
+    /**
+     * The sections currently holding at least one error, for the editor's section chrome.
+     *
+     * Runs the real `Validate()` — the same rules the server enforces — so a section cannot light up
+     * for a reason the save would not also refuse, and cannot stay quiet for one it would.
+     */
+    SectionsWithErrors(): OrderEditorSection[];
+    /**
+     * Save, or throw with the reason the engine gave.
+     *
+     * WHY THIS IS ON THE ENTITY. It was a method on an Angular service, which
+     * `docs/ui-architecture.md` names as the wrong place: "if a method on it loads, saves, validates
+     * or maps entity data, it is in the wrong place." The reason it existed at all is the boolean
+     * return — `Save()` answers true/false and leaves the reason on `LatestResult`, so every caller
+     * wrote the same three lines to turn that into something a person could read. Writing them once
+     * is right; writing them in a service is not.
+     *
+     * A non-Angular host gets this too, which is the test the guidelines actually apply.
+     *
+     * @throws The engine's own message — never a generic one. "Order ORD-000123 cannot be confirmed
+     *         without a customer" is actionable; "the order could not be saved" is not.
+     */
+    SaveOrThrow(): Promise<void>;
+    /**
+     * Whether the Confirm verb should be offered, and why not if it shouldn't.
+     *
+     * Status-only half is {@link CanOfferConfirm}. This adds the two facts the
+     * screen already knows: a payer, and at least one line. The UI stays dumb —
+     * it asks this, then calls {@link Confirm}.
+     */
+    ConfirmEligibility(): TransitionVerdict;
+    /** True when {@link Confirm} is a legal next move from what is on this object. */
+    get CanConfirm(): boolean;
+    /**
+     * Confirm — the irreversible step.
+     *
+     * Setting the status and saving IS the confirm: the server subclass sees the transition into a
+     * booked state and books — journal entries, subscriptions, entitlements, the initial payment —
+     * in one transaction, or refuses with a reason and writes nothing.
+     *
+     * There is no dry run in front of it. Every rule is enforced by the engine itself, and a browser
+     * has already run the tier-independent ones through `Validate()`, so the user is told about a
+     * missing payer without a round trip.
+     */
+    Confirm(): Promise<void>;
+    /**
+     * Load this order and its lines together — the state an editor needs.
+     *
+     * Two calls and no mapping layer: the object bound to the screen is the object that will be
+     * saved. `Lines` is `Load: 'explicit'`, so it has to be asked for; asking here means no caller
+     * can forget and then wonder why an order with lines renders as empty.
+     *
+     * @returns False when the order does not exist, leaving this entity unloaded.
+     */
+    LoadWithLines(orderHeaderID: string): Promise<boolean>;
+    /**
+     * Person-level party defaults after a bill-to / ship-to person is set.
+     *
+     * 1. Copy person bill-to ↔ ship-to when the other side's person is null.
+     * 2. For each side that has a person and no org, stamp the longest-lasting
+     *    active Employee relationship's organization.
+     *
+     * Does not overwrite an org the user already chose. Skips booked/voided orders.
+     */
+    ApplyPersonPartyDefaults(changed?: 'BillTo' | 'ShipTo' | 'Both'): Promise<void>;
+    /**
+     * Stamp BillToOrganizationID or ShipToOrganizationID from the person's longest
+     * active Employee relationship when that side's org is still empty.
+     */
+    AutoPopulateEmployerOrganization(partyRole?: 'ShipTo' | 'BillTo', personID?: string | null): Promise<string | null>;
+}
+//# sourceMappingURL=OrderHeaderEntity.d.ts.map

package/dist/OrderHeaderEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrderHeaderEntity.d.ts","sourceRoot":"","sources":["../src/OrderHeaderEntity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAwE,gBAAgB,EAAW,KAAK,oBAAoB,EAAyB,MAAM,sBAAsB,CAAC;AAGzL,OAAO,EAAE,gCAAgC,EAAsC,MAAM,+BAA+B,CAAC;AACrH,OAAO,EAA4C,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAEzG,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAQhF,uEAAuE;AACvE,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;AAKxF,qBACa,iBAAkB,SAAQ,gCAAgC;IACnE;;;;;;;OAOG;IACH,SAAgB,cAAc,0BAA6D;IAE3F;;;OAGG;IACH,SAAgB,oBAAoB,gCAAmE;IAEhG,yBAAyB,IAAI,IAAI;IAKjC,kBAAkB,IAAI,IAAI;IAI1B,kBAAkB,IAAI,IAAI;IAIjC,IAAW,uBAAuB,IAAI,MAAM,GAAG,IAAI,CAMlD;IAED,IAAW,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAmBtD;IAED,OAAO,CAAC,2BAA2B;IAanC;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,eAAe,UAAS;IAElC,kFAAkF;IAClF,SAAS,CAAC,kBAAkB,IAAI,OAAO;IAOvC;;;;;;;;;;OAUG;IACH;;;;;;;;;OASG;IACH,SAAS,CAAC,uBAAuB,IAAI,iBAAiB;IAKtD,mGAAmG;IACnG,SAAS,CAAC,uBAAuB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM;IAIrE;;;;;;OAMG;IACa,SAAS,CAAC,SAAS,CAAC,EAAE,oBAAoB,GAAG,OAAO;IAapD,QAAQ,IAAI,gBAAgB;IAiF5C;;;;;;;;;OASG;IACH,OAAO,CAAC,4BAA4B;IAcpC,4DAA4D;IAC5D,IAAW,aAAa,IAAI,OAAO,CAElC;IAED;;;;;OAKG;IACH,IAAW,WAAW,IAAI,OAAO,CAIhC;IAED;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA6C9B;;;;;;;;;;;;;OAaG;WACW,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,kBAAkB;IAuBpF;;;;;OAKG;IACI,kBAAkB,IAAI,kBAAkB,EAAE;IAUjD;;;;;;;;;;;;;;OAcG;IACU,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAMzC;;;;;;OAMG;IACI,kBAAkB,IAAI,iBAAiB;IAe9C,kFAAkF;IAClF,IAAW,UAAU,IAAI,OAAO,CAE/B;IAED;;;;;;;;;;OAUG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAUrC;;;;;;;;OAQG;IACU,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOnE;;;;;;;;OAQG;IACU,wBAAwB,CAAC,OAAO,GAAE,QAAQ,GAAG,QAAQ,GAAG,MAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBpG;;;OAGG;IACU,gCAAgC,CACzC,SAAS,GAAE,QAAQ,GAAG,QAAmB,EACzC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAqB5B"}