@tailor-platform/erp-kit 0.5.1 → 0.6.0

package/src/modules/manufacturing/db/manufacturingCostSummary.ts

@@ -0,0 +1,59 @@
+import {
+  db,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { productionOrder } from "./productionOrder";
+
+export const BASE_COST_SUMMARY_STATUSES = [
+  "COLLECTING",
+  "PENDING_VARIANCE_REVIEW",
+  "VARIANCE_REVIEWED",
+  "SETTLED",
+] as const;
+
+export interface CreateManufacturingCostSummaryTypeParams {
+  productionOrderType: TailorAnyDBType;
+}
+
+export function createManufacturingCostSummaryType(
+  params: CreateManufacturingCostSummaryTypeParams,
+) {
+  return db
+    .type("ManufacturingCostSummary", {
+      productionOrderId: db
+        .uuid()
+        .relation({
+          type: "1-1",
+          toward: { type: params.productionOrderType },
+          backward: "manufacturingCostSummary",
+        })
+        .description("Foreign key to ProductionOrder"),
+      plannedMaterialCost: db.float().description("Planned material cost"),
+      plannedLaborCost: db.float().description("Planned labor cost"),
+      plannedMachineCost: db.float().description("Planned machine cost"),
+      plannedOverheadCost: db.float().description("Planned overhead cost"),
+      actualMaterialCost: db.float().description("Actual material cost"),
+      actualLaborCost: db.float().description("Actual labor cost"),
+      actualMachineCost: db.float().description("Actual machine cost"),
+      actualOverheadCost: db.float().description("Actual overhead cost"),
+      currencyCode: db.string().description("Currency code (e.g. USD, EUR)"),
+      reviewedDate: db
+        .datetime({ optional: true })
+        .description("Date when cost summary was reviewed"),
+      reviewerNotes: db.string({ optional: true }).description("Notes from the reviewer"),
+      status: db
+        .enum([...BASE_COST_SUMMARY_STATUSES] as [string, ...string[]])
+        .description(
+          "Lifecycle status: COLLECTING, PENDING_VARIANCE_REVIEW, VARIANCE_REVIEWED, SETTLED",
+        ),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const manufacturingCostSummary = createManufacturingCostSummaryType({
+  productionOrderType: productionOrder,
+});

package/src/modules/manufacturing/db/productionOrder.ts

@@ -0,0 +1,83 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { company as companyStub, site as siteStub, item as itemStub } from "../lib/_db_deps";
+
+export const BASE_PRODUCTION_ORDER_STATUSES = [
+  "DRAFT",
+  "RELEASED",
+  "IN_PROGRESS",
+  "COMPLETED",
+  "TECHNICALLY_COMPLETE",
+  "CLOSED",
+  "CANCELLED",
+] as const;
+
+export interface CreateProductionOrderTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType: TailorAnyDBType;
+  siteType: TailorAnyDBType;
+  itemType: TailorAnyDBType;
+}
+
+export function createProductionOrderType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateProductionOrderTypeParams<F>,
+) {
+  return db
+    .type("ProductionOrder", {
+      orderedItemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.itemType },
+          backward: "productionOrders",
+        })
+        .description("Foreign key to Item – the item to be manufactured"),
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType },
+          backward: "productionOrders",
+        })
+        .description("Foreign key to Company"),
+      siteId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.siteType },
+          backward: "productionOrders",
+        })
+        .description("Foreign key to Site"),
+      plannedQuantity: db
+        .float()
+        .description("Planned production quantity, must be greater than 0"),
+      plannedStartDate: db.datetime().description("Planned start date for the production order"),
+      plannedEndDate: db.datetime().description("Planned end date for the production order"),
+      selectedBomVersionId: db
+        .uuid({ optional: true })
+        .description("Optional reference to BillOfMaterial – resolved at release"),
+      selectedRoutingRevisionId: db
+        .uuid({ optional: true })
+        .description("Optional reference to Routing – resolved at release"),
+      status: db
+        .enum([...BASE_PRODUCTION_ORDER_STATUSES] as [string, ...string[]])
+        .description(
+          "Lifecycle status: DRAFT, RELEASED, IN_PROGRESS, COMPLETED, TECHNICALLY_COMPLETE, CLOSED, CANCELLED",
+        ),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const productionOrder = createProductionOrderType({
+  companyType: companyStub,
+  siteType: siteStub,
+  itemType: itemStub,
+});

package/src/modules/manufacturing/db/productionOrderBomSnapshot.ts

@@ -0,0 +1,44 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { productionOrder } from "./productionOrder";
+
+export interface CreateProductionOrderBomSnapshotTypeParams<
+  F extends Record<string, TailorAnyDBField>,
+> {
+  fields?: F;
+  productionOrderType: TailorAnyDBType;
+}
+
+export function createProductionOrderBomSnapshotType<
+  const F extends Record<string, TailorAnyDBField>,
+>(params: CreateProductionOrderBomSnapshotTypeParams<F>) {
+  return db
+    .type("ProductionOrderBomSnapshot", {
+      productionOrderId: db
+        .uuid()
+        .relation({
+          type: "1-1",
+          toward: { type: params.productionOrderType },
+          backward: "bomSnapshot",
+        })
+        .description("Foreign key to ProductionOrder (one snapshot per order)"),
+      parentItemId: db.uuid().description("Item ID of the parent item in the BOM snapshot"),
+      bomType: db.string().description("BOM type (e.g., STANDARD, PHANTOM)"),
+      snapshotData: db
+        .string({ optional: true })
+        .description("JSON blob containing the full BOM snapshot"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const productionOrderBomSnapshot = createProductionOrderBomSnapshotType({
+  productionOrderType: productionOrder,
+});

package/src/modules/manufacturing/db/productionOrderCostBaseline.ts

@@ -0,0 +1,44 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { productionOrder } from "./productionOrder";
+
+export interface CreateProductionOrderCostBaselineTypeParams<
+  F extends Record<string, TailorAnyDBField>,
+> {
+  fields?: F;
+  productionOrderType: TailorAnyDBType;
+}
+
+export function createProductionOrderCostBaselineType<
+  const F extends Record<string, TailorAnyDBField>,
+>(params: CreateProductionOrderCostBaselineTypeParams<F>) {
+  return db
+    .type("ProductionOrderCostBaseline", {
+      productionOrderId: db
+        .uuid()
+        .relation({
+          type: "1-1",
+          toward: { type: params.productionOrderType },
+          backward: "costBaseline",
+        })
+        .description("Foreign key to ProductionOrder (one baseline per order)"),
+      plannedMaterialCost: db.float().description("Planned total material cost"),
+      plannedLaborCost: db.float().description("Planned total labor cost"),
+      plannedMachineCost: db.float().description("Planned total machine cost"),
+      plannedOverheadCost: db.float().description("Planned total overhead cost"),
+      currencyCode: db.string().description("ISO 4217 currency code (e.g., USD)"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const productionOrderCostBaseline = createProductionOrderCostBaselineType({
+  productionOrderType: productionOrder,
+});

package/src/modules/manufacturing/db/productionOrderMaterialRequirement.ts

@@ -0,0 +1,57 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { item as itemStub } from "../lib/_db_deps";
+import { productionOrder } from "./productionOrder";
+
+export interface CreateProductionOrderMaterialRequirementTypeParams<
+  F extends Record<string, TailorAnyDBField>,
+> {
+  fields?: F;
+  productionOrderType: TailorAnyDBType;
+  itemType: TailorAnyDBType;
+}
+
+export function createProductionOrderMaterialRequirementType<
+  const F extends Record<string, TailorAnyDBField>,
+>(params: CreateProductionOrderMaterialRequirementTypeParams<F>) {
+  return db
+    .type("ProductionOrderMaterialRequirement", {
+      productionOrderId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.productionOrderType },
+          backward: "materialRequirements",
+        })
+        .description("Foreign key to ProductionOrder"),
+      itemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.itemType },
+          backward: "productionOrderMaterialRequirements",
+        })
+        .description("Foreign key to Item – the required material"),
+      requiredQuantity: db.float().description("Required quantity of the material"),
+      unitOfMeasure: db
+        .string({ optional: true })
+        .description("Unit of measure for the required quantity"),
+      plannedUnitCost: db
+        .float({ optional: true })
+        .description("Planned cost per unit of the material"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const productionOrderMaterialRequirement = createProductionOrderMaterialRequirementType({
+  productionOrderType: productionOrder,
+  itemType: itemStub,
+});

package/src/modules/manufacturing/db/productionOrderRoutingSnapshot.ts

@@ -0,0 +1,43 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { productionOrder } from "./productionOrder";
+
+export interface CreateProductionOrderRoutingSnapshotTypeParams<
+  F extends Record<string, TailorAnyDBField>,
+> {
+  fields?: F;
+  productionOrderType: TailorAnyDBType;
+}
+
+export function createProductionOrderRoutingSnapshotType<
+  const F extends Record<string, TailorAnyDBField>,
+>(params: CreateProductionOrderRoutingSnapshotTypeParams<F>) {
+  return db
+    .type("ProductionOrderRoutingSnapshot", {
+      productionOrderId: db
+        .uuid()
+        .relation({
+          type: "1-1",
+          toward: { type: params.productionOrderType },
+          backward: "routingSnapshot",
+        })
+        .description("Foreign key to ProductionOrder (one snapshot per order)"),
+      routingId: db.uuid().description("Routing ID reference for the snapshot"),
+      snapshotData: db
+        .string({ optional: true })
+        .description("JSON blob containing the full routing snapshot"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const productionOrderRoutingSnapshot = createProductionOrderRoutingSnapshotType({
+  productionOrderType: productionOrder,
+});

package/src/modules/manufacturing/db/routing.ts

@@ -0,0 +1,63 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { company as companyStub, site as siteStub, item as itemStub } from "../lib/_db_deps";
+
+export const BASE_ROUTING_STATUSES = ["DRAFT", "ACTIVE", "INACTIVE"] as const;
+
+export interface CreateRoutingTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType: TailorAnyDBType;
+  siteType: TailorAnyDBType;
+  itemType: TailorAnyDBType;
+}
+
+export function createRoutingType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateRoutingTypeParams<F>,
+) {
+  return db
+    .type("Routing", {
+      parentItemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.itemType },
+          backward: "routings",
+        })
+        .description("Foreign key to Item – the manufactured item"),
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType },
+          backward: "routings",
+        })
+        .description("Foreign key to Company"),
+      siteId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.siteType },
+          backward: "routings",
+        })
+        .description("Foreign key to Site – optional site scope"),
+      revisionNumber: db.string({ optional: true }).description("Version identity of the routing"),
+      status: db
+        .enum([...BASE_ROUTING_STATUSES] as [string, ...string[]])
+        .description("Lifecycle status: DRAFT, ACTIVE, INACTIVE"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const routing = createRoutingType({
+  companyType: companyStub,
+  siteType: siteStub,
+  itemType: itemStub,
+});

package/src/modules/manufacturing/db/routingOperation.ts

@@ -0,0 +1,57 @@
+import {
+  db,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { routing } from "./routing";
+import { workCenter } from "./workCenter";
+
+export interface CreateRoutingOperationTypeParams {
+  routingType: TailorAnyDBType;
+  workCenterType: TailorAnyDBType;
+}
+
+export function createRoutingOperationType(params: CreateRoutingOperationTypeParams) {
+  return db
+    .type("RoutingOperation", {
+      routingId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.routingType },
+          backward: "routingOperations",
+        })
+        .description("Foreign key to Routing"),
+      sequenceNumber: db.int().description("Step order within the routing"),
+      operationDescription: db
+        .string({ optional: true })
+        .description("Human-readable description of the operation"),
+      workCenterId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.workCenterType },
+          backward: "routingOperations",
+        })
+        .description("Foreign key to WorkCenter"),
+      standardSetupTime: db.float().description("Standard setup time (>= 0)"),
+      standardRunTime: db.float().description("Standard run time per unit (>= 0)"),
+      operatorInstructions: db
+        .string({ optional: true })
+        .description("Free-text instructions for the operator"),
+      ...db.fields.timestamps(),
+    })
+    .indexes({
+      fields: ["routingId", "sequenceNumber"],
+      unique: true,
+      name: "routing_operation_routing_seq_idx",
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const routingOperation = createRoutingOperationType({
+  routingType: routing,
+  workCenterType: workCenter,
+});

package/src/modules/manufacturing/db/workCenter.ts

@@ -0,0 +1,87 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { company as companyStub, site as siteStub } from "../lib/_db_deps";
+
+export const BASE_WORK_CENTER_STATUSES = ["DRAFT", "ACTIVE", "INACTIVE"] as const;
+
+export const OVERHEAD_ABSORPTION_METHODS = [
+  "PERCENT_OF_LABOR_COST",
+  "PERCENT_OF_MACHINE_COST",
+  "FIXED_AMOUNT_PER_GOOD_UNIT",
+] as const;
+
+export interface CreateWorkCenterTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType: TailorAnyDBType;
+  siteType: TailorAnyDBType;
+}
+
+export function createWorkCenterType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateWorkCenterTypeParams<F>,
+) {
+  return db
+    .type("WorkCenter", {
+      code: db.string().description("Work-center code, unique within company and site scope"),
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType },
+          backward: "workCenters",
+        })
+        .description("Foreign key to Company"),
+      siteId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.siteType },
+          backward: "workCenters",
+        })
+        .description("Foreign key to Site; required when company uses site-level work centers"),
+      status: db
+        .enum([...BASE_WORK_CENTER_STATUSES] as [string, ...string[]])
+        .description("Lifecycle status: DRAFT, ACTIVE, INACTIVE"),
+      capacityAssumptions: db
+        .float()
+        .description(
+          "Capacity assumption expressed in a consistent planning unit; must be positive",
+        ),
+      laborRate: db
+        .float({ optional: true })
+        .description("Standard labor rate per planning unit; must be zero or greater"),
+      machineRate: db
+        .float({ optional: true })
+        .description("Standard machine rate per planning unit; must be zero or greater"),
+      calendarReference: db
+        .string({ optional: true })
+        .description("Calendar identifier; required when activating the work center"),
+      overheadAbsorptionMethod: db
+        .enum([...OVERHEAD_ABSORPTION_METHODS] as [string, ...string[]], {
+          optional: true,
+        })
+        .description(
+          "Method for absorbing overhead: PERCENT_OF_LABOR_COST, PERCENT_OF_MACHINE_COST, or FIXED_AMOUNT_PER_GOOD_UNIT",
+        ),
+      overheadAbsorptionCurrency: db
+        .string({ optional: true })
+        .description(
+          "ISO 4217 currency code for overhead absorption; required when method is FIXED_AMOUNT_PER_GOOD_UNIT",
+        ),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .indexes({
+      fields: ["code", "companyId", "siteId"],
+      unique: true,
+      name: "work_center_code_company_site_idx",
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const workCenter = createWorkCenterType({ companyType: companyStub, siteType: siteStub });

package/src/modules/manufacturing/db/workOrder.ts

@@ -0,0 +1,65 @@
+import {
+  db,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { productionOrder } from "./productionOrder";
+import { workCenter } from "./workCenter";
+
+export const BASE_WORK_ORDER_STATUSES = [
+  "PENDING",
+  "IN_PROGRESS",
+  "PAUSED",
+  "COMPLETE",
+  "CANCELLED",
+] as const;
+
+export interface CreateWorkOrderTypeParams {
+  productionOrderType: TailorAnyDBType;
+  workCenterType: TailorAnyDBType;
+}
+
+export function createWorkOrderType(params: CreateWorkOrderTypeParams) {
+  return db
+    .type("WorkOrder", {
+      productionOrderId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.productionOrderType },
+          backward: "workOrders",
+        })
+        .description("Foreign key to ProductionOrder"),
+      routingOperationSequenceNumber: db
+        .int()
+        .description("Sequence number of the routing operation"),
+      workCenterId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.workCenterType },
+          backward: "workOrders",
+        })
+        .description("Foreign key to WorkCenter"),
+      plannedQuantity: db.float().description("Planned quantity to produce, must be >= 0"),
+      completedQuantity: db.float().description("Completed quantity, must be >= 0"),
+      scrapQuantity: db.float().description("Scrap quantity, must be >= 0"),
+      actualSetupTime: db.float().description("Actual setup time in minutes, must be >= 0"),
+      actualRunTime: db.float().description("Actual run time in minutes, must be >= 0"),
+      actualStartDate: db.datetime({ optional: true }).description("Actual start date and time"),
+      pauseReason: db.string({ optional: true }).description("Reason for pausing the work order"),
+      executionNotes: db.string({ optional: true }).description("Free-form notes about execution"),
+      status: db
+        .enum([...BASE_WORK_ORDER_STATUSES] as [string, ...string[]])
+        .description("Lifecycle status: PENDING, IN_PROGRESS, PAUSED, COMPLETE, CANCELLED"),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const workOrder = createWorkOrderType({
+  productionOrderType: productionOrder,
+  workCenterType: workCenter,
+});

package/src/modules/manufacturing/db/workOrderExecutionEvent.ts

@@ -0,0 +1,54 @@
+import {
+  db,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { workOrder } from "./workOrder";
+
+export const EXECUTION_EVENT_TYPES = [
+  "STARTED",
+  "PAUSED",
+  "RESUMED",
+  "PROGRESS_REPORTED",
+  "COMPLETED",
+] as const;
+
+export interface CreateWorkOrderExecutionEventTypeParams {
+  workOrderType: TailorAnyDBType;
+}
+
+export function createWorkOrderExecutionEventType(params: CreateWorkOrderExecutionEventTypeParams) {
+  return db
+    .type("WorkOrderExecutionEvent", {
+      workOrderId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.workOrderType },
+          backward: "executionEvents",
+        })
+        .description("Foreign key to WorkOrder"),
+      eventType: db
+        .enum([...EXECUTION_EVENT_TYPES] as [string, ...string[]])
+        .description("Event type: STARTED, PAUSED, RESUMED, PROGRESS_REPORTED, COMPLETED"),
+      timestamp: db.datetime().description("When the event occurred"),
+      quantity: db
+        .float({ optional: true })
+        .description("Quantity associated with the event, must be >= 0"),
+      timeValue: db
+        .float({ optional: true })
+        .description("Time value associated with the event, must be >= 0"),
+      scrapValue: db
+        .float({ optional: true })
+        .description("Scrap value associated with the event, must be >= 0"),
+      notes: db.string({ optional: true }).description("Optional notes about the event"),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const workOrderExecutionEvent = createWorkOrderExecutionEventType({
+  workOrderType: workOrder,
+});