@naisys/erp-shared 3.0.0-beta.10

package/dist/admin-types.js

@@ -0,0 +1,41 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasLinkSchema } from "./hateoas-types.js";
+export const AdminInfoResponseSchema = z.object({
+    erpDbPath: z.string(),
+    erpDbSize: z.number().optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+export const AdminAttachmentItemSchema = z.object({
+    id: z.string(),
+    filename: z.string(),
+    fileSize: z.number(),
+    fileHash: z.string(),
+    uploadedBy: z.string(),
+    createdAt: z.string(),
+});
+export const AdminAttachmentListRequestSchema = z.object({
+    page: z.coerce.number().optional().default(1),
+    pageSize: z.coerce.number().optional().default(50),
+});
+export const AdminAttachmentListResponseSchema = z.object({
+    attachments: z.array(AdminAttachmentItemSchema),
+    total: z.number(),
+    page: z.number(),
+    pageSize: z.number(),
+    _links: z.array(HateoasLinkSchema),
+});
+export const PinoLogEntrySchema = z.object({
+    level: z.number(),
+    time: z.number(),
+    msg: z.string(),
+    detail: z.string().optional(),
+});
+export const ServerLogRequestSchema = z.object({
+    lines: z.coerce.number().optional().default(200),
+    minLevel: z.coerce.number().optional(),
+});
+export const ServerLogResponseSchema = z.object({
+    entries: z.array(PinoLogEntrySchema),
+    fileName: z.string(),
+    fileSize: z.number().optional(),
+});

package/dist/api-types.js

@@ -0,0 +1,4 @@
+import { z } from "zod/v4";
+export const HelloResponseSchema = z.object({
+    message: z.string(),
+});

package/dist/audit-types.js

@@ -0,0 +1,19 @@
+import { z } from "zod/v4";
+export const AuditEntrySchema = z.object({
+    id: z.number(),
+    entityType: z.string(),
+    entityId: z.number(),
+    action: z.string(),
+    field: z.string(),
+    oldValue: z.string().nullable(),
+    newValue: z.string().nullable(),
+    userId: z.number(),
+    createdAt: z.iso.datetime(),
+});
+export const AuditListResponseSchema = z.object({
+    items: z.array(AuditEntrySchema),
+});
+export const AuditQuerySchema = z.object({
+    entityType: z.string(),
+    entityId: z.coerce.number().int(),
+});

package/dist/auth-types.js

@@ -0,0 +1,15 @@
+import { z } from "zod/v4";
+export const LoginRequestSchema = z
+    .object({
+    username: z.string().min(1),
+    password: z.string().min(1),
+})
+    .strict();
+export const AuthUserSchema = z.object({
+    id: z.number(),
+    username: z.string(),
+    permissions: z.array(z.string()).optional(),
+});
+export const LoginResponseSchema = z.object({
+    user: AuthUserSchema,
+});

package/dist/error-types.js

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+export const ErrorResponseSchema = z.object({
+    statusCode: z.number().int(),
+    error: z.string(),
+    message: z.string(),
+});

package/dist/field-ref-types.js

@@ -0,0 +1,55 @@
+import { z } from "zod/v4";
+import { FieldTypeEnum } from "./field-types.js";
+import { HateoasActionSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+// Field definition summary within a field ref
+export const FieldRefFieldSchema = z.object({
+    seqNo: z.number(),
+    label: z.string(),
+    type: FieldTypeEnum,
+});
+// Full field ref response shape (plan level)
+export const FieldRefSchema = z.object({
+    id: z.number(),
+    seqNo: z.number(),
+    title: z.string(),
+    sourceOpSeqNo: z.number(),
+    sourceOpTitle: z.string(),
+    sourceStepSeqNo: z.number(),
+    sourceStepTitle: z.string(),
+    fields: z.array(FieldRefFieldSchema),
+    createdAt: z.iso.datetime(),
+    createdBy: z.string(),
+    _links: z.array(HateoasLinkSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+// Input for creating a field ref
+export const CreateFieldRefSchema = z
+    .object({
+    seqNo: z.number().int().min(1).optional(),
+    title: z.string().min(1).max(200),
+    sourceOpSeqNo: z.number().int().min(1),
+    sourceStepSeqNo: z.number().int().min(1),
+})
+    .strict();
+// List response
+export const FieldRefListResponseSchema = z.object({
+    items: z.array(FieldRefSchema),
+    total: z.number(),
+    nextSeqNo: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+// Field ref value summary embedded in OperationRun GET response
+// Uses FieldValueEntry from step-run-types for compatibility with FieldValueRunList
+import { FieldValueEntrySchema } from "./step-run-types.js";
+export const FieldRefValueSummarySchema = z.object({
+    seqNo: z.number(),
+    title: z.string(),
+    sourceOpSeqNo: z.number(),
+    sourceOpTitle: z.string(),
+    sourceStepSeqNo: z.number(),
+    sourceStepTitle: z.string(),
+    multiSet: z.boolean(),
+    fieldValues: z.array(FieldValueEntrySchema),
+});

package/dist/field-types.js

@@ -0,0 +1,61 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+export const FieldTypeEnum = z.enum([
+    "string",
+    "number",
+    "date",
+    "datetime",
+    "yesNo",
+    "checkbox",
+    "attachment",
+]);
+export const FieldType = FieldTypeEnum.enum;
+// Full field response shape
+export const FieldSchema = z.object({
+    id: z.number(),
+    fieldSetId: z.number(),
+    seqNo: z.number(),
+    label: z.string(),
+    type: FieldTypeEnum,
+    isArray: z.boolean(),
+    required: z.boolean(),
+    createdAt: z.iso.datetime(),
+    createdBy: z.string(),
+    updatedAt: z.iso.datetime(),
+    updatedBy: z.string(),
+    _links: z.array(HateoasLinkSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+// Input for creating a field
+export const CreateFieldSchema = z
+    .object({
+    seqNo: z.number().int().min(1).optional(),
+    label: z.string().min(1).max(200),
+    type: FieldTypeEnum.optional(),
+    isArray: z.boolean().optional(),
+    required: z.boolean().optional(),
+})
+    .strict();
+// Input for batch creating fields
+export const BatchCreateFieldSchema = z.object({
+    items: z.array(CreateFieldSchema).min(1).max(100),
+});
+// Input for updating a field
+export const UpdateFieldSchema = z
+    .object({
+    seqNo: z.number().int().min(1).optional(),
+    label: z.string().min(1).max(200).optional(),
+    type: FieldTypeEnum.optional(),
+    isArray: z.boolean().optional(),
+    required: z.boolean().optional(),
+})
+    .strict();
+// List response
+export const FieldListResponseSchema = z.object({
+    items: z.array(FieldSchema),
+    total: z.number(),
+    nextSeqNo: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});

package/dist/hateoas-types.js

@@ -0,0 +1 @@
+export { HateoasActionSchema, HateoasActionTemplateSchema, HateoasLinkSchema, HateoasLinksSchema, HateoasLinkTemplateSchema, } from "@naisys/common";

package/dist/index.js

@@ -0,0 +1,25 @@
+export * from "./admin-types.js";
+export * from "./api-types.js";
+export * from "./audit-types.js";
+export * from "./auth-types.js";
+export * from "./error-types.js";
+export * from "./field-ref-types.js";
+export * from "./field-types.js";
+export * from "./hateoas-types.js";
+export * from "./inventory-types.js";
+export * from "./item-instance-types.js";
+export * from "./item-types.js";
+export * from "./labor-ticket-types.js";
+export * from "./mutation-types.js";
+export * from "./operation-dependency-types.js";
+export * from "./operation-run-comment-types.js";
+export * from "./operation-run-types.js";
+export * from "./operation-types.js";
+export * from "./order-revision-types.js";
+export * from "./order-run-types.js";
+export * from "./order-types.js";
+export * from "./revision-diff-types.js";
+export * from "./step-run-types.js";
+export * from "./step-types.js";
+export * from "./user-types.js";
+export * from "./work-center-types.js";

package/dist/inventory-types.js

@@ -0,0 +1,26 @@
+import { z } from "zod/v4";
+import { HateoasActionTemplateSchema, HateoasLinkSchema, } from "./hateoas-types.js";
+// Query params for inventory list (all item instances across all items)
+export const InventoryListQuerySchema = z.object({
+    page: z.coerce.number().int().min(1).optional().default(1),
+    pageSize: z.coerce.number().int().min(1).max(100).optional().default(20),
+    search: z.string().optional(),
+});
+// Flattened inventory item for the list
+export const InventoryItemSchema = z.object({
+    id: z.number(),
+    itemKey: z.string(),
+    key: z.string(),
+    quantity: z.number().nullable(),
+    orderKey: z.string().nullable(),
+    orderRunNo: z.number().nullable(),
+    createdAt: z.iso.datetime(),
+});
+export const InventoryListResponseSchema = z.object({
+    items: z.array(InventoryItemSchema),
+    total: z.number(),
+    page: z.number(),
+    pageSize: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _actionTemplates: z.array(HateoasActionTemplateSchema).optional(),
+});

package/dist/item-instance-types.js

@@ -0,0 +1,52 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasActionTemplateSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+import { FieldValueEntrySchema } from "./step-run-types.js";
+// Full item instance response shape
+export const ItemInstanceSchema = z.object({
+    id: z.number(),
+    itemKey: z.string(),
+    orderKey: z.string().nullable(),
+    orderRunNo: z.number().nullable(),
+    key: z.string(),
+    quantity: z.number().nullable(),
+    fieldValues: z.array(FieldValueEntrySchema),
+    createdBy: z.string(),
+    createdAt: z.iso.datetime(),
+    updatedBy: z.string(),
+    updatedAt: z.iso.datetime(),
+    _links: z.array(HateoasLinkSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+    _actionTemplates: z.array(HateoasActionTemplateSchema).optional(),
+});
+// Input for creating an item instance
+export const CreateItemInstanceSchema = z
+    .object({
+    key: z.string().min(1).max(200),
+    quantity: z.number().nullable().optional(),
+    orderRunId: z.number().nullable().optional(),
+})
+    .strict();
+// Input for updating an item instance
+export const UpdateItemInstanceSchema = z
+    .object({
+    key: z.string().min(1).max(200).optional(),
+    quantity: z.number().nullable().optional(),
+    orderRunId: z.number().nullable().optional(),
+})
+    .strict();
+// Query params for listing item instances
+export const ItemInstanceListQuerySchema = z.object({
+    page: z.coerce.number().int().min(1).optional().default(1),
+    pageSize: z.coerce.number().int().min(1).max(100).optional().default(20),
+    search: z.string().optional(),
+});
+// List response
+export const ItemInstanceListResponseSchema = z.object({
+    items: z.array(ItemInstanceSchema),
+    total: z.number(),
+    page: z.number(),
+    pageSize: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});

package/dist/item-types.js

@@ -0,0 +1,55 @@
+import { z } from "zod/v4";
+import { FieldListResponseSchema } from "./field-types.js";
+import { HateoasActionSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+// Full item response shape
+export const ItemSchema = z.object({
+    id: z.number(),
+    key: z.string(),
+    description: z.string(),
+    fields: FieldListResponseSchema,
+    createdBy: z.string(),
+    createdAt: z.iso.datetime(),
+    updatedBy: z.string(),
+    updatedAt: z.iso.datetime(),
+    _links: z.array(HateoasLinkSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+// Input for creating an item
+export const CreateItemSchema = z
+    .object({
+    key: z
+        .string()
+        .min(1)
+        .max(100)
+        .regex(/^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$/, "Key must be alphanumeric with hyphens"),
+    description: z.string().max(2000).optional().default(""),
+})
+    .strict();
+// Input for updating an item
+export const UpdateItemSchema = z
+    .object({
+    key: z
+        .string()
+        .min(1)
+        .max(100)
+        .regex(/^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$/, "Key must be alphanumeric with hyphens")
+        .optional(),
+    description: z.string().max(2000).optional(),
+})
+    .strict();
+// Query params for listing items
+export const ItemListQuerySchema = z.object({
+    page: z.coerce.number().int().min(1).optional().default(1),
+    pageSize: z.coerce.number().int().min(1).max(100).optional().default(20),
+    search: z.string().optional(),
+});
+// List response
+export const ItemListResponseSchema = z.object({
+    items: z.array(ItemSchema),
+    total: z.number(),
+    page: z.number(),
+    pageSize: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});

package/dist/labor-ticket-types.js

@@ -0,0 +1,31 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasActionTemplateSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+export const LaborTicketSchema = z.object({
+    id: z.number(),
+    operationRunId: z.number(),
+    userId: z.number(),
+    username: z.string(),
+    runId: z.number().nullable(),
+    clockIn: z.iso.datetime(),
+    clockOut: z.iso.datetime().nullable(),
+    cost: z.number().nullable(),
+    createdAt: z.iso.datetime(),
+    createdBy: z.string(),
+    updatedAt: z.iso.datetime(),
+    updatedBy: z.string(),
+    _links: z.array(HateoasLinkSchema).optional(),
+});
+export const ClockOutLaborTicketSchema = z
+    .object({
+    userId: z.number().int().optional(),
+    ticketId: z.number().int().optional(),
+})
+    .strict();
+export const LaborTicketListResponseSchema = z.object({
+    items: z.array(LaborTicketSchema),
+    total: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+    _actionTemplates: z.array(HateoasActionTemplateSchema).optional(),
+});

package/dist/mutation-types.js

@@ -0,0 +1,97 @@
+/**
+ * Slim response schemas for POST/PUT/DELETE mutations.
+ *
+ * By default, mutations return a slim response (identifiers + _actions).
+ * Callers can send `Prefer: return=representation` to get the full entity
+ * response instead (useful for UI clients that patch state in place).
+ */
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasLinkSchema } from "./hateoas-types.js";
+import { OperationRunStatusEnum } from "./operation-run-types.js";
+import { RevisionStatusEnum } from "./order-revision-types.js";
+import { OrderRunStatusEnum } from "./order-run-types.js";
+import { FieldValidationSchema, FieldValueSchema } from "./step-run-types.js";
+// ── Base mutation responses ─────────────────────────────────────────
+/** PUT / generic mutation — just updated actions */
+export const MutateResponseSchema = z.object({
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+/** POST create — server-generated id + self link + actions */
+export const CreateResponseSchema = MutateResponseSchema.extend({
+    id: z.number(),
+    _links: z.array(HateoasLinkSchema).optional(),
+});
+// ── Entity create variants ──────────────────────────────────────────
+/** Orders, items, work centers, item instances (key-based) */
+export const KeyCreateResponseSchema = CreateResponseSchema.extend({
+    key: z.string(),
+});
+/** Operations, steps, fields, field refs (seqNo-based) */
+export const SeqNoCreateResponseSchema = CreateResponseSchema.extend({
+    seqNo: z.number(),
+});
+/** Batch create (steps, fields) */
+export const BatchSeqNoCreateResponseSchema = z.object({
+    items: z.array(z.object({ id: z.number(), seqNo: z.number() })),
+    total: z.number(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+/** Order revision create */
+export const RevisionCreateResponseSchema = CreateResponseSchema.extend({
+    revNo: z.number(),
+});
+/** Order run create */
+export const RunCreateResponseSchema = CreateResponseSchema.extend({
+    runNo: z.number(),
+});
+/** User create (ERP) */
+export const UserCreateResponseSchema = z.object({
+    id: z.number(),
+    username: z.string(),
+    apiKey: z.string().nullable().optional(),
+    _links: z.array(HateoasLinkSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+// ── Transition responses ────────────────────────────────────────────
+/** Order run transition (start / close / complete / cancel / reopen) */
+export const OrderRunTransitionSchema = z.object({
+    status: OrderRunStatusEnum,
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+/** Operation run transition (start / complete / skip / fail / reopen) */
+export const OperationRunTransitionSlimSchema = z.object({
+    status: OperationRunStatusEnum,
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+/** Step run transition (complete / reopen) */
+export const StepRunTransitionSlimSchema = z.object({
+    completed: z.boolean(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+/** Order revision transition (approve / obsolete) */
+export const OrderRevisionTransitionSchema = z.object({
+    status: RevisionStatusEnum,
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+// ── Field value mutation responses ──────────────────────────────────
+/** Single field value PUT — echo value + validation + actions */
+export const FieldValueMutateResponseSchema = z.object({
+    value: FieldValueSchema,
+    validation: FieldValidationSchema,
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+/** Batch field value PUT */
+export const BatchFieldValueMutateResponseSchema = z.object({
+    items: z.array(z.object({
+        fieldSeqNo: z.number(),
+        value: FieldValueSchema,
+        validation: FieldValidationSchema,
+    })),
+    total: z.number(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+/** Delete field value set */
+export const DeleteSetMutateResponseSchema = z.object({
+    setCount: z.number(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});

package/dist/operation-dependency-types.js

@@ -0,0 +1,24 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasActionTemplateSchema, HateoasLinkSchema, } from "./hateoas-types.js";
+// Full dependency response shape
+export const OperationDependencySchema = z.object({
+    id: z.number(),
+    predecessorSeqNo: z.number(),
+    predecessorTitle: z.string(),
+    createdAt: z.iso.datetime(),
+    createdBy: z.string(),
+});
+// Input for creating a dependency
+export const CreateOperationDependencySchema = z
+    .object({
+    predecessorSeqNo: z.number().int().min(1),
+})
+    .strict();
+// List response
+export const OperationDependencyListResponseSchema = z.object({
+    items: z.array(OperationDependencySchema),
+    total: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _actions: z.array(HateoasActionSchema).optional(),
+    _actionTemplates: z.array(HateoasActionTemplateSchema).optional(),
+});

package/dist/operation-run-comment-types.js

@@ -0,0 +1,30 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+export const OperationRunCommentTypeEnum = z.enum([
+    "note",
+    "issue",
+    "feedback",
+]);
+export const OperationRunCommentType = OperationRunCommentTypeEnum.enum;
+export const OperationRunCommentSchema = z.object({
+    id: z.number(),
+    operationRunId: z.number(),
+    type: OperationRunCommentTypeEnum,
+    body: z.string(),
+    createdAt: z.iso.datetime(),
+    createdBy: z.string(),
+    _links: z.array(HateoasLinkSchema).optional(),
+});
+export const CreateOperationRunCommentSchema = z
+    .object({
+    type: OperationRunCommentTypeEnum.optional(),
+    body: z.string().min(1).max(5000),
+})
+    .strict();
+export const OperationRunCommentListResponseSchema = z.object({
+    items: z.array(OperationRunCommentSchema),
+    total: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});

package/dist/operation-run-types.js

@@ -0,0 +1,82 @@
+import { z } from "zod/v4";
+import { FieldRefValueSummarySchema } from "./field-ref-types.js";
+import { HateoasActionSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+import { OperationPredecessorSchema } from "./operation-types.js";
+// Step summary embedded in operation run GET responses
+export const StepRunSummarySchema = z.object({
+    seqNo: z.number(),
+    title: z.string(),
+    completed: z.boolean(),
+});
+export const OperationRunStatusEnum = z.enum([
+    "blocked",
+    "pending",
+    "in_progress",
+    "completed",
+    "skipped",
+    "failed",
+]);
+export const OperationRunStatus = OperationRunStatusEnum.enum;
+// Full operation run response shape
+export const OperationRunSchema = z.object({
+    id: z.number(),
+    orderRunId: z.number(),
+    operationId: z.number(),
+    seqNo: z.number(),
+    title: z.string(),
+    description: z.string(),
+    workCenterKey: z.string().nullable(),
+    stepCount: z.number().optional(),
+    predecessors: z.array(OperationPredecessorSchema).optional(),
+    status: OperationRunStatusEnum,
+    assignedTo: z.string().nullable(),
+    cost: z.number().nullable(),
+    note: z.string().nullable(),
+    completedAt: z.iso.datetime().nullable(),
+    stepSummary: z.array(StepRunSummarySchema).optional(),
+    fieldRefSummary: z.array(FieldRefValueSummarySchema).optional(),
+    createdAt: z.iso.datetime(),
+    createdBy: z.string(),
+    updatedAt: z.iso.datetime(),
+    updatedBy: z.string(),
+    _links: z.array(HateoasLinkSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+// Input for updating an operation run
+export const UpdateOperationRunSchema = z
+    .object({
+    assignedToId: z.number().int().nullable().optional(),
+})
+    .strict();
+// Body for any status transition that accepts an optional note
+// Accept null/undefined so callers don't need to send -d '{}' on POST
+// endpoints where the body is entirely optional. A simpler
+// .nullable().default({}) doesn't narrow the output type in zod v4,
+// so we use a union + transform instead.
+export const TransitionNoteSchema = z
+    .union([
+    z.object({ note: z.string().max(2000).optional() }).strict(),
+    z.null(),
+    z.undefined(),
+])
+    .transform((v) => v ?? {});
+// Slim transition response (start/complete/skip/fail/reopen)
+export const OperationRunTransitionSchema = z.object({
+    id: z.number(),
+    status: OperationRunStatusEnum,
+    assignedTo: z.string().nullable(),
+    cost: z.number().nullable(),
+    note: z.string().nullable(),
+    completedAt: z.iso.datetime().nullable(),
+    updatedAt: z.iso.datetime(),
+    updatedBy: z.string(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+// List response
+export const OperationRunListResponseSchema = z.object({
+    items: z.array(OperationRunSchema),
+    total: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});