cabloy 5.1.113 → 5.1.115

package/vona/src/suite/a-commerce/modules/commerce-trade/src/.metadata/index.ts

@@ -5,11 +5,17 @@ import type { TableIdentity } from 'table-identity';
 /** entity: begin */
 export * from '../entity/cart.tsx';
 export * from '../entity/cartItem.tsx';
+export * from '../entity/order.tsx';
+export * from '../entity/orderAudit.tsx';
+export * from '../entity/orderLine.tsx';
 export * from '../entity/stockAudit.tsx';
 export * from '../entity/stockBalance.tsx';
 export * from '../entity/stockReservation.tsx';
 import type { IEntityOptionsCart } from '../entity/cart.tsx';
 import type { IEntityOptionsCartItem } from '../entity/cartItem.tsx';
+import type { IEntityOptionsOrder } from '../entity/order.tsx';
+import type { IEntityOptionsOrderAudit } from '../entity/orderAudit.tsx';
+import type { IEntityOptionsOrderLine } from '../entity/orderLine.tsx';
 import type { IEntityOptionsStockAudit } from '../entity/stockAudit.tsx';
 import type { IEntityOptionsStockBalance } from '../entity/stockBalance.tsx';
 import type { IEntityOptionsStockReservation } from '../entity/stockReservation.tsx';
@@ -19,6 +25,9 @@ declare module 'vona-module-a-orm' {
     export interface IEntityRecord {
       'commerce-trade:cart': IEntityOptionsCart;
 'commerce-trade:cartItem': IEntityOptionsCartItem;
+'commerce-trade:order': IEntityOptionsOrder;
+'commerce-trade:orderAudit': IEntityOptionsOrderAudit;
+'commerce-trade:orderLine': IEntityOptionsOrderLine;
 'commerce-trade:stockAudit': IEntityOptionsStockAudit;
 'commerce-trade:stockBalance': IEntityOptionsStockBalance;
 'commerce-trade:stockReservation': IEntityOptionsStockReservation;
@@ -33,12 +42,18 @@ declare module 'vona-module-commerce-trade' {
 /** entity: begin */
 import type { EntityCart } from '../entity/cart.tsx';
 import type { EntityCartItem } from '../entity/cartItem.tsx';
+import type { EntityOrder } from '../entity/order.tsx';
+import type { EntityOrderAudit } from '../entity/orderAudit.tsx';
+import type { EntityOrderLine } from '../entity/orderLine.tsx';
 import type { EntityStockAudit } from '../entity/stockAudit.tsx';
 import type { EntityStockBalance } from '../entity/stockBalance.tsx';
 import type { EntityStockReservation } from '../entity/stockReservation.tsx';
 export interface IModuleEntity {
   'cart': EntityCartMeta;
 'cartItem': EntityCartItemMeta;
+'order': EntityOrderMeta;
+'orderAudit': EntityOrderAuditMeta;
+'orderLine': EntityOrderLineMeta;
 'stockAudit': EntityStockAuditMeta;
 'stockBalance': EntityStockBalanceMeta;
 'stockReservation': EntityStockReservationMeta;
@@ -47,11 +62,17 @@ export interface IModuleEntity {
 /** entity: begin */
 export type EntityCartTableName = 'commerceTradeCart';
 export type EntityCartItemTableName = 'commerceTradeCartItem';
+export type EntityOrderTableName = 'commerceTradeOrder';
+export type EntityOrderAuditTableName = 'commerceTradeOrderAudit';
+export type EntityOrderLineTableName = 'commerceTradeOrderLine';
 export type EntityStockAuditTableName = 'commerceTradeStockAudit';
 export type EntityStockBalanceTableName = 'commerceTradeStockBalance';
 export type EntityStockReservationTableName = 'commerceTradeStockReservation';
 export type EntityCartMeta=TypeEntityMeta<EntityCart,EntityCartTableName>;
 export type EntityCartItemMeta=TypeEntityMeta<EntityCartItem,EntityCartItemTableName>;
+export type EntityOrderMeta=TypeEntityMeta<EntityOrder,EntityOrderTableName>;
+export type EntityOrderAuditMeta=TypeEntityMeta<EntityOrderAudit,EntityOrderAuditTableName>;
+export type EntityOrderLineMeta=TypeEntityMeta<EntityOrderLine,EntityOrderLineTableName>;
 export type EntityStockAuditMeta=TypeEntityMeta<EntityStockAudit,EntityStockAuditTableName>;
 export type EntityStockBalanceMeta=TypeEntityMeta<EntityStockBalance,EntityStockBalanceTableName>;
 export type EntityStockReservationMeta=TypeEntityMeta<EntityStockReservation,EntityStockReservationTableName>;
@@ -59,6 +80,9 @@ declare module 'vona-module-a-orm' {
   export interface ITableRecord {
     'commerceTradeCart': EntityCartMeta;
 'commerceTradeCartItem': EntityCartItemMeta;
+'commerceTradeOrder': EntityOrderMeta;
+'commerceTradeOrderAudit': EntityOrderAuditMeta;
+'commerceTradeOrderLine': EntityOrderLineMeta;
 'commerceTradeStockAudit': EntityStockAuditMeta;
 'commerceTradeStockBalance': EntityStockBalanceMeta;
 'commerceTradeStockReservation': EntityStockReservationMeta;
@@ -74,6 +98,18 @@ declare module 'vona-module-commerce-trade' {
       fields?: TypeEntityOptionsFields<EntityCartItem, IEntityOptionsCartItem[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IEntityOptionsOrder {
+      fields?: TypeEntityOptionsFields<EntityOrder, IEntityOptionsOrder[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IEntityOptionsOrderAudit {
+      fields?: TypeEntityOptionsFields<EntityOrderAudit, IEntityOptionsOrderAudit[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IEntityOptionsOrderLine {
+      fields?: TypeEntityOptionsFields<EntityOrderLine, IEntityOptionsOrderLine[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IEntityOptionsStockAudit {
       fields?: TypeEntityOptionsFields<EntityStockAudit, IEntityOptionsStockAudit[TypeSymbolKeyFieldsMore]>;
     }
@@ -90,11 +126,17 @@ declare module 'vona-module-commerce-trade' {
 /** model: begin */
 export * from '../model/cart.ts';
 export * from '../model/cartItem.ts';
+export * from '../model/order.ts';
+export * from '../model/orderAudit.ts';
+export * from '../model/orderLine.ts';
 export * from '../model/stockAudit.ts';
 export * from '../model/stockBalance.ts';
 export * from '../model/stockReservation.ts';
 import type { IModelOptionsCart } from '../model/cart.ts';
 import type { IModelOptionsCartItem } from '../model/cartItem.ts';
+import type { IModelOptionsOrder } from '../model/order.ts';
+import type { IModelOptionsOrderAudit } from '../model/orderAudit.ts';
+import type { IModelOptionsOrderLine } from '../model/orderLine.ts';
 import type { IModelOptionsStockAudit } from '../model/stockAudit.ts';
 import type { IModelOptionsStockBalance } from '../model/stockBalance.ts';
 import type { IModelOptionsStockReservation } from '../model/stockReservation.ts';
@@ -104,6 +146,9 @@ declare module 'vona-module-a-orm' {
     export interface IModelRecord {
       'commerce-trade:cart': IModelOptionsCart;
 'commerce-trade:cartItem': IModelOptionsCartItem;
+'commerce-trade:order': IModelOptionsOrder;
+'commerce-trade:orderAudit': IModelOptionsOrderAudit;
+'commerce-trade:orderLine': IModelOptionsOrderLine;
 'commerce-trade:stockAudit': IModelOptionsStockAudit;
 'commerce-trade:stockBalance': IModelOptionsStockBalance;
 'commerce-trade:stockReservation': IModelOptionsStockReservation;
@@ -135,6 +180,39 @@ declare module 'vona-module-commerce-trade' {
             get $onionOptions(): IModelOptionsCartItem;
           }
 
+        export interface ModelOrder {
+          /** @internal */
+          get scope(): ScopeModuleCommerceTrade;
+        }
+
+          export interface ModelOrder {
+            get $beanFullName(): 'commerce-trade.model.order';
+            get $onionName(): 'commerce-trade:order';
+            get $onionOptions(): IModelOptionsOrder;
+          }
+
+        export interface ModelOrderAudit {
+          /** @internal */
+          get scope(): ScopeModuleCommerceTrade;
+        }
+
+          export interface ModelOrderAudit {
+            get $beanFullName(): 'commerce-trade.model.orderAudit';
+            get $onionName(): 'commerce-trade:orderAudit';
+            get $onionOptions(): IModelOptionsOrderAudit;
+          }
+
+        export interface ModelOrderLine {
+          /** @internal */
+          get scope(): ScopeModuleCommerceTrade;
+        }
+
+          export interface ModelOrderLine {
+            get $beanFullName(): 'commerce-trade.model.orderLine';
+            get $onionName(): 'commerce-trade:orderLine';
+            get $onionOptions(): IModelOptionsOrderLine;
+          }
+
         export interface ModelStockAudit {
           /** @internal */
           get scope(): ScopeModuleCommerceTrade;
@@ -172,12 +250,18 @@ declare module 'vona-module-commerce-trade' {
 /** model: begin */
 import type { ModelCart } from '../model/cart.ts';
 import type { ModelCartItem } from '../model/cartItem.ts';
+import type { ModelOrder } from '../model/order.ts';
+import type { ModelOrderAudit } from '../model/orderAudit.ts';
+import type { ModelOrderLine } from '../model/orderLine.ts';
 import type { ModelStockAudit } from '../model/stockAudit.ts';
 import type { ModelStockBalance } from '../model/stockBalance.ts';
 import type { ModelStockReservation } from '../model/stockReservation.ts';
 export interface IModuleModel {
   'cart': ModelCart;
 'cartItem': ModelCartItem;
+'order': ModelOrder;
+'orderAudit': ModelOrderAudit;
+'orderLine': ModelOrderLine;
 'stockAudit': ModelStockAudit;
 'stockBalance': ModelStockBalance;
 'stockReservation': ModelStockReservation;
@@ -190,6 +274,9 @@ declare module 'vona' {
   export interface IBeanRecordGeneral {
     'commerce-trade.model.cart': ModelCart;
 'commerce-trade.model.cartItem': ModelCartItem;
+'commerce-trade.model.order': ModelOrder;
+'commerce-trade.model.orderAudit': ModelOrderAudit;
+'commerce-trade.model.orderLine': ModelOrderLine;
 'commerce-trade.model.stockAudit': ModelStockAudit;
 'commerce-trade.model.stockBalance': ModelStockBalance;
 'commerce-trade.model.stockReservation': ModelStockReservation;
@@ -205,6 +292,11 @@ declare module 'vona-module-commerce-trade' {
           items: IModelRelationHasMany<'commerce-trade:cartItem', 'cartId', false, 'id'|'skuId'|'quantity', undefined, undefined, undefined>;
         };
       }
+export interface IModelOptionsOrder {
+        relations: {
+          lines: IModelRelationHasMany<'commerce-trade:orderLine', 'orderId', false, '*', undefined, undefined, undefined>;
+        };
+      }
   export interface ModelCart {
       [SymbolKeyEntity]: EntityCart;
       [SymbolKeyEntityMeta]: EntityCartMeta;
@@ -259,6 +351,87 @@ export interface ModelCartItem {
 updateById<T extends IModelUpdateOptions<EntityCartItem,ModelCartItem>>(id: TableIdentity, data: TypeModelMutateRelationData<EntityCartItem,ModelCartItem, T>, options?: T): Promise<TypeModelMutateRelationData<EntityCartItem,ModelCartItem, T>>;
 deleteById<T extends IModelDeleteOptions<EntityCartItem,ModelCartItem>>(id: TableIdentity, options?: T): Promise<void>;
     }
+export interface ModelOrder {
+      [SymbolKeyEntity]: EntityOrder;
+      [SymbolKeyEntityMeta]: EntityOrderMeta;
+      [SymbolKeyModelOptions]: IModelOptionsOrder;
+      get<T extends IModelGetOptions<EntityOrder,ModelOrder>>(where: TypeModelWhere<EntityOrder>, options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityOrder,ModelOrder>>(where: TypeModelWhere<EntityOrder>, options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityOrder,ModelOrder>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T> | undefined>;
+      mget<T extends IModelGetOptions<EntityOrder,ModelOrder>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityOrder,ModelOrder,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityOrder, ModelOrder, T>>;
+      select<T extends IModelSelectParams<EntityOrder,ModelOrder,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T>[]>;
+      insert<T extends IModelInsertOptions<EntityOrder,ModelOrder>>(data?: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T, true>>;
+      insertBulk<T extends IModelInsertOptions<EntityOrder,ModelOrder>>(items: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T, true>[]>;
+      update<T extends IModelUpdateOptions<EntityOrder,ModelOrder>>(data: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T>>;
+      updateBulk<T extends IModelUpdateOptions<EntityOrder,ModelOrder>>(items: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T>[]>;
+      delete<T extends IModelDeleteOptions<EntityOrder,ModelOrder>>(where?: TypeModelWhere<EntityOrder>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<EntityOrder,ModelOrder>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<EntityOrder,ModelOrder>>(data?: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T>>;
+      mutateBulk<T extends IModelMutateOptions<EntityOrder,ModelOrder>>(items: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T>[]>;
+      count<T extends IModelSelectCountParams<EntityOrder,ModelOrder,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<string | undefined>;
+      increment<T extends IModelIncrementParams<EntityOrder,ModelOrder,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      decrement<T extends IModelIncrementParams<EntityOrder,ModelOrder,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      aggregate<T extends IModelSelectAggrParams<EntityOrder,ModelOrder,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<EntityOrder,ModelOrder,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityOrder, T>[]>;
+      getById<T extends IModelGetOptions<EntityOrder,ModelOrder>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T> | undefined>;
+updateById<T extends IModelUpdateOptions<EntityOrder,ModelOrder>>(id: TableIdentity, data: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T>>;
+deleteById<T extends IModelDeleteOptions<EntityOrder,ModelOrder>>(id: TableIdentity, options?: T): Promise<void>;
+    }
+export interface ModelOrderAudit {
+      [SymbolKeyEntity]: EntityOrderAudit;
+      [SymbolKeyEntityMeta]: EntityOrderAuditMeta;
+      [SymbolKeyModelOptions]: IModelOptionsOrderAudit;
+      get<T extends IModelGetOptions<EntityOrderAudit,ModelOrderAudit>>(where: TypeModelWhere<EntityOrderAudit>, options?: T): Promise<TypeModelRelationResult<EntityOrderAudit, ModelOrderAudit, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityOrderAudit,ModelOrderAudit>>(where: TypeModelWhere<EntityOrderAudit>, options?: T): Promise<TypeModelRelationResult<EntityOrderAudit, ModelOrderAudit, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityOrderAudit,ModelOrderAudit>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityOrderAudit, ModelOrderAudit, T> | undefined>;
+      mget<T extends IModelGetOptions<EntityOrderAudit,ModelOrderAudit>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityOrderAudit, ModelOrderAudit, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityOrderAudit,ModelOrderAudit,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityOrderAudit, ModelOrderAudit, T>>;
+      select<T extends IModelSelectParams<EntityOrderAudit,ModelOrderAudit,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityOrderAudit, ModelOrderAudit, T>[]>;
+      insert<T extends IModelInsertOptions<EntityOrderAudit,ModelOrderAudit>>(data?: TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T, true>>;
+      insertBulk<T extends IModelInsertOptions<EntityOrderAudit,ModelOrderAudit>>(items: TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T, true>[]>;
+      update<T extends IModelUpdateOptions<EntityOrderAudit,ModelOrderAudit>>(data: TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>>;
+      updateBulk<T extends IModelUpdateOptions<EntityOrderAudit,ModelOrderAudit>>(items: TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>[]>;
+      delete<T extends IModelDeleteOptions<EntityOrderAudit,ModelOrderAudit>>(where?: TypeModelWhere<EntityOrderAudit>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<EntityOrderAudit,ModelOrderAudit>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<EntityOrderAudit,ModelOrderAudit>>(data?: TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>>;
+      mutateBulk<T extends IModelMutateOptions<EntityOrderAudit,ModelOrderAudit>>(items: TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>[]>;
+      count<T extends IModelSelectCountParams<EntityOrderAudit,ModelOrderAudit,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<string | undefined>;
+      increment<T extends IModelIncrementParams<EntityOrderAudit,ModelOrderAudit,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      decrement<T extends IModelIncrementParams<EntityOrderAudit,ModelOrderAudit,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      aggregate<T extends IModelSelectAggrParams<EntityOrderAudit,ModelOrderAudit,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<EntityOrderAudit,ModelOrderAudit,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityOrderAudit, T>[]>;
+      getById<T extends IModelGetOptions<EntityOrderAudit,ModelOrderAudit>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityOrderAudit, ModelOrderAudit, T> | undefined>;
+updateById<T extends IModelUpdateOptions<EntityOrderAudit,ModelOrderAudit>>(id: TableIdentity, data: TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrderAudit,ModelOrderAudit, T>>;
+deleteById<T extends IModelDeleteOptions<EntityOrderAudit,ModelOrderAudit>>(id: TableIdentity, options?: T): Promise<void>;
+    }
+export interface ModelOrderLine {
+      [SymbolKeyEntity]: EntityOrderLine;
+      [SymbolKeyEntityMeta]: EntityOrderLineMeta;
+      [SymbolKeyModelOptions]: IModelOptionsOrderLine;
+      get<T extends IModelGetOptions<EntityOrderLine,ModelOrderLine>>(where: TypeModelWhere<EntityOrderLine>, options?: T): Promise<TypeModelRelationResult<EntityOrderLine, ModelOrderLine, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityOrderLine,ModelOrderLine>>(where: TypeModelWhere<EntityOrderLine>, options?: T): Promise<TypeModelRelationResult<EntityOrderLine, ModelOrderLine, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityOrderLine,ModelOrderLine>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityOrderLine, ModelOrderLine, T> | undefined>;
+      mget<T extends IModelGetOptions<EntityOrderLine,ModelOrderLine>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityOrderLine, ModelOrderLine, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityOrderLine,ModelOrderLine,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityOrderLine, ModelOrderLine, T>>;
+      select<T extends IModelSelectParams<EntityOrderLine,ModelOrderLine,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityOrderLine, ModelOrderLine, T>[]>;
+      insert<T extends IModelInsertOptions<EntityOrderLine,ModelOrderLine>>(data?: TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T, true>>;
+      insertBulk<T extends IModelInsertOptions<EntityOrderLine,ModelOrderLine>>(items: TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T, true>[]>;
+      update<T extends IModelUpdateOptions<EntityOrderLine,ModelOrderLine>>(data: TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>>;
+      updateBulk<T extends IModelUpdateOptions<EntityOrderLine,ModelOrderLine>>(items: TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>[]>;
+      delete<T extends IModelDeleteOptions<EntityOrderLine,ModelOrderLine>>(where?: TypeModelWhere<EntityOrderLine>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<EntityOrderLine,ModelOrderLine>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<EntityOrderLine,ModelOrderLine>>(data?: TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>>;
+      mutateBulk<T extends IModelMutateOptions<EntityOrderLine,ModelOrderLine>>(items: TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>[]>;
+      count<T extends IModelSelectCountParams<EntityOrderLine,ModelOrderLine,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<string | undefined>;
+      increment<T extends IModelIncrementParams<EntityOrderLine,ModelOrderLine,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      decrement<T extends IModelIncrementParams<EntityOrderLine,ModelOrderLine,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      aggregate<T extends IModelSelectAggrParams<EntityOrderLine,ModelOrderLine,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<EntityOrderLine,ModelOrderLine,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityOrderLine, T>[]>;
+      getById<T extends IModelGetOptions<EntityOrderLine,ModelOrderLine>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityOrderLine, ModelOrderLine, T> | undefined>;
+updateById<T extends IModelUpdateOptions<EntityOrderLine,ModelOrderLine>>(id: TableIdentity, data: TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrderLine,ModelOrderLine, T>>;
+deleteById<T extends IModelDeleteOptions<EntityOrderLine,ModelOrderLine>>(id: TableIdentity, options?: T): Promise<void>;
+    }
 export interface ModelStockAudit {
       [SymbolKeyEntity]: EntityStockAudit;
       [SymbolKeyEntityMeta]: EntityStockAuditMeta;
@@ -345,14 +518,43 @@ declare module 'vona-module-a-orm' {
   export interface IModelClassRecord {
     'commerce-trade:cart': ModelCart;
 'commerce-trade:cartItem': ModelCartItem;
+'commerce-trade:order': ModelOrder;
+'commerce-trade:orderAudit': ModelOrderAudit;
+'commerce-trade:orderLine': ModelOrderLine;
 'commerce-trade:stockAudit': ModelStockAudit;
 'commerce-trade:stockBalance': ModelStockBalance;
 'commerce-trade:stockReservation': ModelStockReservation;
   }
 }
 /** model: end */
+/** bean: begin */
+export * from '../bean/bean.scheduleOrderExpiry.ts';
+
+import 'vona';
+declare module 'vona' {
+  
+  
+}
+declare module 'vona-module-commerce-trade' {
+  
+        export interface BeanScheduleOrderExpiry {
+          /** @internal */
+          get scope(): ScopeModuleCommerceTrade;
+        } 
+}
+/** bean: end */
+/** bean: begin */
+import type { BeanScheduleOrderExpiry } from '../bean/bean.scheduleOrderExpiry.ts';
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGlobal {
+    'scheduleOrderExpiry': BeanScheduleOrderExpiry;
+  }
+}
+/** bean: end */
 /** service: begin */
 export * from '../service/cart.ts';
+export * from '../service/order.ts';
 export * from '../service/stockAudit.ts';
 export * from '../service/stockBalance.ts';
 
@@ -361,6 +563,7 @@ declare module 'vona-module-a-bean' {
   
     export interface IServiceRecord {
       'commerce-trade:cart': never;
+'commerce-trade:order': never;
 'commerce-trade:stockAudit': never;
 'commerce-trade:stockBalance': never;
     }
@@ -380,6 +583,17 @@ declare module 'vona-module-commerce-trade' {
             
           }
 
+        export interface ServiceOrder {
+          /** @internal */
+          get scope(): ScopeModuleCommerceTrade;
+        }
+
+          export interface ServiceOrder {
+            get $beanFullName(): 'commerce-trade.service.order';
+            get $onionName(): 'commerce-trade:order';
+            
+          }
+
         export interface ServiceStockAudit {
           /** @internal */
           get scope(): ScopeModuleCommerceTrade;
@@ -405,10 +619,12 @@ declare module 'vona-module-commerce-trade' {
 /** service: end */
 /** service: begin */
 import type { ServiceCart } from '../service/cart.ts';
+import type { ServiceOrder } from '../service/order.ts';
 import type { ServiceStockAudit } from '../service/stockAudit.ts';
 import type { ServiceStockBalance } from '../service/stockBalance.ts';
 export interface IModuleService {
   'cart': ServiceCart;
+'order': ServiceOrder;
 'stockAudit': ServiceStockAudit;
 'stockBalance': ServiceStockBalance;
 }
@@ -419,6 +635,7 @@ import 'vona';
 declare module 'vona' {
   export interface IBeanRecordGeneral {
     'commerce-trade.service.cart': ServiceCart;
+'commerce-trade.service.order': ServiceOrder;
 'commerce-trade.service.stockAudit': ServiceStockAudit;
 'commerce-trade.service.stockBalance': ServiceStockBalance;
   }
@@ -468,6 +685,11 @@ export * from '../dto/cartAddItem.tsx';
 export * from '../dto/cartItem.tsx';
 export * from '../dto/cartUpdateItem.tsx';
 export * from '../dto/cartView.tsx';
+export * from '../dto/checkoutCreate.tsx';
+export * from '../dto/checkoutResult.tsx';
+export * from '../dto/orderAddressSnapshot.tsx';
+export * from '../dto/orderCouponSnapshot.tsx';
+export * from '../dto/orderLineSkuAttributeSnapshot.tsx';
 export * from '../dto/stockAdjust.tsx';
 export * from '../dto/stockAuditCreate.tsx';
 export * from '../dto/stockAuditSelectReq.tsx';
@@ -485,6 +707,11 @@ import type { IDtoOptionsCartAddItem } from '../dto/cartAddItem.tsx';
 import type { IDtoOptionsCartItem } from '../dto/cartItem.tsx';
 import type { IDtoOptionsCartUpdateItem } from '../dto/cartUpdateItem.tsx';
 import type { IDtoOptionsCartView } from '../dto/cartView.tsx';
+import type { IDtoOptionsCheckoutCreate } from '../dto/checkoutCreate.tsx';
+import type { IDtoOptionsCheckoutResult } from '../dto/checkoutResult.tsx';
+import type { IDtoOptionsOrderAddressSnapshot } from '../dto/orderAddressSnapshot.tsx';
+import type { IDtoOptionsOrderCouponSnapshot } from '../dto/orderCouponSnapshot.tsx';
+import type { IDtoOptionsOrderLineSkuAttributeSnapshot } from '../dto/orderLineSkuAttributeSnapshot.tsx';
 import type { IDtoOptionsStockAdjust } from '../dto/stockAdjust.tsx';
 import type { IDtoOptionsStockAuditCreate } from '../dto/stockAuditCreate.tsx';
 import type { IDtoOptionsStockAuditSelectReq } from '../dto/stockAuditSelectReq.tsx';
@@ -506,6 +733,11 @@ declare module 'vona-module-a-web' {
 'commerce-trade:cartItem': IDtoOptionsCartItem;
 'commerce-trade:cartUpdateItem': IDtoOptionsCartUpdateItem;
 'commerce-trade:cartView': IDtoOptionsCartView;
+'commerce-trade:checkoutCreate': IDtoOptionsCheckoutCreate;
+'commerce-trade:checkoutResult': IDtoOptionsCheckoutResult;
+'commerce-trade:orderAddressSnapshot': IDtoOptionsOrderAddressSnapshot;
+'commerce-trade:orderCouponSnapshot': IDtoOptionsOrderCouponSnapshot;
+'commerce-trade:orderLineSkuAttributeSnapshot': IDtoOptionsOrderLineSkuAttributeSnapshot;
 'commerce-trade:stockAdjust': IDtoOptionsStockAdjust;
 'commerce-trade:stockAuditCreate': IDtoOptionsStockAuditCreate;
 'commerce-trade:stockAuditSelectReq': IDtoOptionsStockAuditSelectReq;
@@ -532,6 +764,11 @@ import type { DtoCartAddItem } from '../dto/cartAddItem.tsx';
 import type { DtoCartItem } from '../dto/cartItem.tsx';
 import type { DtoCartUpdateItem } from '../dto/cartUpdateItem.tsx';
 import type { DtoCartView } from '../dto/cartView.tsx';
+import type { DtoCheckoutCreate } from '../dto/checkoutCreate.tsx';
+import type { DtoCheckoutResult } from '../dto/checkoutResult.tsx';
+import type { DtoOrderAddressSnapshot } from '../dto/orderAddressSnapshot.tsx';
+import type { DtoOrderCouponSnapshot } from '../dto/orderCouponSnapshot.tsx';
+import type { DtoOrderLineSkuAttributeSnapshot } from '../dto/orderLineSkuAttributeSnapshot.tsx';
 import type { DtoStockAdjust } from '../dto/stockAdjust.tsx';
 import type { DtoStockAuditCreate } from '../dto/stockAuditCreate.tsx';
 import type { DtoStockAuditSelectReq } from '../dto/stockAuditSelectReq.tsx';
@@ -563,6 +800,26 @@ declare module 'vona-module-commerce-trade' {
       fields?: TypeEntityOptionsFields<DtoCartView, IDtoOptionsCartView[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsCheckoutCreate {
+      fields?: TypeEntityOptionsFields<DtoCheckoutCreate, IDtoOptionsCheckoutCreate[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsCheckoutResult {
+      fields?: TypeEntityOptionsFields<DtoCheckoutResult, IDtoOptionsCheckoutResult[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsOrderAddressSnapshot {
+      fields?: TypeEntityOptionsFields<DtoOrderAddressSnapshot, IDtoOptionsOrderAddressSnapshot[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsOrderCouponSnapshot {
+      fields?: TypeEntityOptionsFields<DtoOrderCouponSnapshot, IDtoOptionsOrderCouponSnapshot[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsOrderLineSkuAttributeSnapshot {
+      fields?: TypeEntityOptionsFields<DtoOrderLineSkuAttributeSnapshot, IDtoOptionsOrderLineSkuAttributeSnapshot[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsStockAdjust {
       fields?: TypeEntityOptionsFields<DtoStockAdjust, IDtoOptionsStockAdjust[TypeSymbolKeyFieldsMore]>;
     }
@@ -618,9 +875,11 @@ declare module 'vona-module-commerce-trade' {
 /** dto: end */
 /** controller: begin */
 export * from '../controller/cart.ts';
+export * from '../controller/checkout.ts';
 export * from '../controller/stockAudit.ts';
 export * from '../controller/stockBalance.ts';
 import type { IControllerOptionsCart } from '../controller/cart.ts';
+import type { IControllerOptionsCheckout } from '../controller/checkout.ts';
 import type { IControllerOptionsStockAudit } from '../controller/stockAudit.ts';
 import type { IControllerOptionsStockBalance } from '../controller/stockBalance.ts';
 import 'vona-module-a-web';
@@ -628,6 +887,7 @@ declare module 'vona-module-a-web' {
   
     export interface IControllerRecord {
       'commerce-trade:cart': IControllerOptionsCart;
+'commerce-trade:checkout': IControllerOptionsCheckout;
 'commerce-trade:stockAudit': IControllerOptionsStockAudit;
 'commerce-trade:stockBalance': IControllerOptionsStockBalance;
     }
@@ -647,6 +907,17 @@ declare module 'vona-module-commerce-trade' {
             get $onionOptions(): IControllerOptionsCart;
           }
 
+        export interface ControllerCheckout {
+          /** @internal */
+          get scope(): ScopeModuleCommerceTrade;
+        }
+
+          export interface ControllerCheckout {
+            get $beanFullName(): 'commerce-trade.controller.checkout';
+            get $onionName(): 'commerce-trade:checkout';
+            get $onionOptions(): IControllerOptionsCheckout;
+          }
+
         export interface ControllerStockAudit {
           /** @internal */
           get scope(): ScopeModuleCommerceTrade;
@@ -674,6 +945,8 @@ declare module 'vona-module-commerce-trade' {
 // @ts-ignore ignore
 import type { ControllerCart } from '../controller/cart.ts';
 // @ts-ignore ignore
+import type { ControllerCheckout } from '../controller/checkout.ts';
+// @ts-ignore ignore
 import type { ControllerStockAudit } from '../controller/stockAudit.ts';
 // @ts-ignore ignore
 import type { ControllerStockBalance } from '../controller/stockBalance.ts';
@@ -683,6 +956,10 @@ declare module 'vona-module-commerce-trade' {
       actions?: TypeControllerOptionsActions<ControllerCart>;
     }
 
+    export interface IControllerOptionsCheckout {
+      actions?: TypeControllerOptionsActions<ControllerCheckout>;
+    }
+
     export interface IControllerOptionsStockAudit {
       actions?: TypeControllerOptionsActions<ControllerStockAudit>;
     }

package/vona/src/suite/a-commerce/modules/commerce-trade/src/bean/bean.scheduleOrderExpiry.ts

@@ -0,0 +1,26 @@
+import type { IScheduleExecute } from 'vona-module-a-schedule';
+
+import { BeanBase } from 'vona';
+import { Schedule } from 'vona-module-a-schedule';
+
+const ExpiryBatchLimit = 100;
+
+@Schedule({ repeat: { every: 60 * 1000 } })
+export class BeanScheduleOrderExpiry extends BeanBase implements IScheduleExecute {
+  async execute() {
+    const orders = await this.scope.model.order.select({
+      where: {
+        state: 'awaiting_payment',
+        reservationExpiresAt: { _lte_: new Date() },
+      },
+      orders: [
+        ['reservationExpiresAt', 'asc'],
+        ['id', 'asc'],
+      ],
+      limit: ExpiryBatchLimit,
+    });
+    for (const order of orders) {
+      await this.scope.service.order.expireIfDue(order.id);
+    }
+  }
+}

package/vona/src/suite/a-commerce/modules/commerce-trade/src/bean/meta.index.ts

@@ -9,6 +9,14 @@ import { $tableColumns } from 'vona-module-a-ormutils';
     ...$tableColumns('commerceTradeCart', 'userId'),
     ...$tableColumns('commerceTradeCartItem', 'cartId'),
     ...$tableColumns('commerceTradeCartItem', 'skuId'),
+    ...$tableColumns('commerceTradeOrder', 'userId'),
+    ...$tableColumns('commerceTradeOrder', 'correlationId'),
+    ...$tableColumns('commerceTradeOrder', 'state'),
+    ...$tableColumns('commerceTradeOrder', 'reservationExpiresAt'),
+    ...$tableColumns('commerceTradeOrderLine', 'orderId'),
+    ...$tableColumns('commerceTradeOrderAudit', 'orderId'),
+    ...$tableColumns('commerceTradeOrderAudit', 'correlationId'),
+    ...$tableColumns('commerceTradeOrderLine', 'skuId'),
     ...$tableColumns('commerceTradeStockAudit', 'stockBalanceId'),
     ...$tableColumns('commerceTradeStockAudit', 'skuId'),
     ...$tableColumns('commerceTradeStockAudit', 'stockReservationId'),
@@ -16,6 +24,7 @@ import { $tableColumns } from 'vona-module-a-ormutils';
     ...$tableColumns('commerceTradeStockBalance', 'skuId'),
     ...$tableColumns('commerceTradeStockReservation', 'stockBalanceId'),
     ...$tableColumns('commerceTradeStockReservation', 'skuId'),
+    ...$tableColumns('commerceTradeStockReservation', 'orderLineId'),
     ...$tableColumns('commerceTradeStockReservation', 'correlationId'),
     ...$tableColumns('commerceTradeStockReservation', 'state'),
   },

package/vona/src/suite/a-commerce/modules/commerce-trade/src/bean/meta.version.ts

@@ -28,6 +28,10 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
       table
         .tableIdentity(entityStockReservation.skuId)
         .comment(entityStockReservation.$comment.skuId);
+      table
+        .tableIdentity(entityStockReservation.orderLineId)
+        .nullable()
+        .comment(entityStockReservation.$comment.orderLineId);
       table
         .integer(entityStockReservation.quantity)
         .comment(entityStockReservation.$comment.quantity);
@@ -79,5 +83,76 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
       table.tableIdentity(entityCartItem.skuId).comment(entityCartItem.$comment.skuId);
       table.integer(entityCartItem.quantity).comment(entityCartItem.$comment.quantity);
     });
+
+    const entityOrder = this.scope.entity.order;
+    await this.bean.model.createTable(entityOrder.$table, table => {
+      table.comment(entityOrder.$comment.$table);
+      table.basicFields();
+      table.userId(entityOrder.userId).comment(entityOrder.$comment.userId);
+      table.tableIdentity(entityOrder.addressId).comment(entityOrder.$comment.addressId);
+      table.string(entityOrder.correlationId, 80).comment(entityOrder.$comment.correlationId);
+      table.json(entityOrder.addressSnapshot).comment(entityOrder.$comment.addressSnapshot);
+      table
+        .json(entityOrder.couponSnapshot)
+        .nullable()
+        .comment(entityOrder.$comment.couponSnapshot);
+      table.string(entityOrder.state, 30).comment(entityOrder.$comment.state);
+      table.string(entityOrder.currency, 3).comment(entityOrder.$comment.currency);
+      table
+        .integer(entityOrder.eligibleSubtotalCents)
+        .comment(entityOrder.$comment.eligibleSubtotalCents);
+      table.integer(entityOrder.discountCents).comment(entityOrder.$comment.discountCents);
+      table.integer(entityOrder.payableTotalCents).comment(entityOrder.$comment.payableTotalCents);
+      table
+        .dateTime(entityOrder.reservationExpiresAt)
+        .comment(entityOrder.$comment.reservationExpiresAt);
+    });
+
+    const entityOrderLine = this.scope.entity.orderLine;
+    await this.bean.model.createTable(entityOrderLine.$table, table => {
+      table.comment(entityOrderLine.$comment.$table);
+      table.basicFields();
+      table.tableIdentity(entityOrderLine.orderId).comment(entityOrderLine.$comment.orderId);
+      table.tableIdentity(entityOrderLine.skuId).comment(entityOrderLine.$comment.skuId);
+      table.tableIdentity(entityOrderLine.productId).comment(entityOrderLine.$comment.productId);
+      table
+        .string(entityOrderLine.skuCodeSnapshot, 100)
+        .comment(entityOrderLine.$comment.skuCodeSnapshot);
+      table
+        .string(entityOrderLine.titleSnapshot, 100)
+        .comment(entityOrderLine.$comment.titleSnapshot);
+      table
+        .json(entityOrderLine.skuAttributesSnapshot)
+        .comment(entityOrderLine.$comment.skuAttributesSnapshot);
+      table
+        .integer(entityOrderLine.unitPriceCents)
+        .comment(entityOrderLine.$comment.unitPriceCents);
+      table.integer(entityOrderLine.quantity).comment(entityOrderLine.$comment.quantity);
+      table
+        .integer(entityOrderLine.eligibleSubtotalCents)
+        .comment(entityOrderLine.$comment.eligibleSubtotalCents);
+      table
+        .integer(entityOrderLine.lineTotalCents)
+        .comment(entityOrderLine.$comment.lineTotalCents);
+    });
+
+    // This v1 schema is intentionally rebuild-only while Commerce is pre-deployment.
+    const entityOrderAudit = this.scope.entity.orderAudit;
+    await this.bean.model.createTable(entityOrderAudit.$table, table => {
+      table.comment(entityOrderAudit.$comment.$table);
+      table.basicFields();
+      table.tableIdentity(entityOrderAudit.orderId).comment(entityOrderAudit.$comment.orderId);
+      table.string(entityOrderAudit.operation, 20).comment(entityOrderAudit.$comment.operation);
+      table
+        .string(entityOrderAudit.fromState, 30)
+        .nullable()
+        .comment(entityOrderAudit.$comment.fromState);
+      table.string(entityOrderAudit.toState, 30).comment(entityOrderAudit.$comment.toState);
+      table.userId(entityOrderAudit.actorId).nullable().comment(entityOrderAudit.$comment.actorId);
+      table
+        .string(entityOrderAudit.correlationId, 100)
+        .comment(entityOrderAudit.$comment.correlationId);
+      table.string(entityOrderAudit.reason, 255).comment(entityOrderAudit.$comment.reason);
+    });
   }
 }