@naisys/erp-shared 3.0.0-beta.10

package/dist/operation-types.js

@@ -0,0 +1,58 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+// Predecessor summary (included in list responses)
+export const OperationPredecessorSchema = z.object({
+    seqNo: z.number(),
+    title: z.string(),
+});
+// Step summary (included in single operation GET responses)
+export const StepSummarySchema = z.object({
+    seqNo: z.number(),
+    title: z.string(),
+});
+// Full operation response shape
+export const OperationSchema = z.object({
+    id: z.number(),
+    orderRevId: z.number(),
+    seqNo: z.number(),
+    title: z.string(),
+    description: z.string(),
+    workCenterKey: z.string().nullable(),
+    stepCount: z.number().optional(),
+    stepSummary: z.array(StepSummarySchema).optional(),
+    predecessors: z.array(OperationPredecessorSchema).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 creating an operation
+export const CreateOperationSchema = z
+    .object({
+    seqNo: z.number().int().min(1).optional(),
+    title: z.string().min(1).max(200),
+    description: z.string().max(2000).optional(),
+    workCenterKey: z.string().max(100).nullable().optional(),
+    predecessorSeqNos: z.array(z.number().int().min(1)).optional(),
+})
+    .strict();
+// Input for updating an operation
+export const UpdateOperationSchema = z
+    .object({
+    title: z.string().min(1).max(200).optional(),
+    description: z.string().max(2000).optional(),
+    workCenterKey: z.string().max(100).nullable().optional(),
+    seqNo: z.number().int().min(1).optional(),
+})
+    .strict();
+// List response
+export const OperationListResponseSchema = z.object({
+    items: z.array(OperationSchema),
+    total: z.number(),
+    nextSeqNo: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});

package/dist/order-revision-types.js

@@ -0,0 +1,61 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+// Operation summary embedded in revision GET responses
+export const RevisionOperationSummarySchema = z.object({
+    seqNo: z.number(),
+    title: z.string(),
+});
+export const RevisionStatusEnum = z.enum(["draft", "approved", "obsolete"]);
+export const RevisionStatus = RevisionStatusEnum.enum;
+// Full revision response shape
+export const OrderRevisionSchema = z.object({
+    id: z.number(),
+    orderId: z.number(),
+    revNo: z.number(),
+    status: RevisionStatusEnum,
+    description: z.string(),
+    changeSummary: z.string().nullable(),
+    itemKey: z.string().nullable(),
+    operationSummary: z.array(RevisionOperationSummarySchema).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 creating a revision
+export const CreateOrderRevisionSchema = z
+    .object({
+    description: z.string().max(2000).optional(),
+    changeSummary: z.string().max(2000).optional(),
+})
+    .strict();
+// Input for updating a revision
+export const UpdateOrderRevisionSchema = z
+    .object({
+    description: z.string().max(2000).optional(),
+    changeSummary: z.string().max(2000).optional(),
+})
+    .strict();
+// Query params for listing revisions
+export const OrderRevisionListQuerySchema = z.object({
+    page: z.coerce.number().int().min(1).optional().default(1),
+    pageSize: z.coerce.number().int().min(1).max(100).optional().default(20),
+    status: RevisionStatusEnum.optional(),
+    includeObsolete: z
+        .enum(["true", "false"])
+        .transform((v) => v === "true")
+        .optional()
+        .default(false),
+});
+// List response
+export const OrderRevisionListResponseSchema = z.object({
+    items: z.array(OrderRevisionSchema),
+    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/order-run-types.js

@@ -0,0 +1,141 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasActionTemplateSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+import { OperationRunStatusEnum } from "./operation-run-types.js";
+// Operation summary embedded in order run GET responses
+export const OperationRunSummarySchema = z.object({
+    seqNo: z.number(),
+    title: z.string(),
+    status: OperationRunStatusEnum,
+});
+export const OrderRunStatusEnum = z.enum([
+    "released",
+    "started",
+    "closed",
+    "cancelled",
+]);
+export const OrderRunStatus = OrderRunStatusEnum.enum;
+export const OrderRunPriorityEnum = z.enum([
+    "low",
+    "medium",
+    "high",
+    "critical",
+]);
+export const OrderRunPriority = OrderRunPriorityEnum.enum;
+// Full order run response shape
+export const OrderRunSchema = z.object({
+    id: z.number(),
+    runNo: z.number(),
+    orderId: z.number(),
+    orderKey: z.string(),
+    revNo: z.number(),
+    itemKey: z.string().nullable(),
+    instanceId: z.number().nullable(),
+    instanceKey: z.string().nullable(),
+    status: OrderRunStatusEnum,
+    priority: OrderRunPriorityEnum,
+    cost: z.number().nullable(),
+    dueAt: z.string().nullable(),
+    releaseNote: z.string().nullable(),
+    operationSummary: z.array(OperationRunSummarySchema).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 creating an order run
+export const CreateOrderRunSchema = z
+    .object({
+    revNo: z.number().int().min(1).optional(),
+    priority: OrderRunPriorityEnum.optional().default("medium"),
+    dueAt: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Must be YYYY-MM-DD"),
+    releaseNote: z.string().max(2000).optional(),
+})
+    .strict();
+// Input for updating an order run
+export const UpdateOrderRunSchema = z
+    .object({
+    priority: OrderRunPriorityEnum.optional(),
+    dueAt: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, "Must be YYYY-MM-DD")
+        .nullable()
+        .optional(),
+    releaseNote: z.string().max(2000).nullable().optional(),
+})
+    .strict();
+// Input for completing an order run (creates item instance + closes run)
+export const CompleteOrderRunSchema = z
+    .object({
+    instanceKey: z.string().max(200).optional(),
+    quantity: z.number().nullable().optional(),
+    fieldValues: z
+        .array(z.object({
+        fieldId: z.number().int(),
+        value: z.string().max(2000),
+        setIndex: z.number().int().min(0).optional(),
+    }))
+        .optional(),
+})
+    .strict();
+// Query params for listing order runs
+export const OrderRunListQuerySchema = z.object({
+    page: z.coerce.number().int().min(1).optional().default(1),
+    pageSize: z.coerce.number().int().min(1).max(100).optional().default(20),
+    status: OrderRunStatusEnum.optional(),
+    priority: OrderRunPriorityEnum.optional(),
+    search: z.string().optional(),
+});
+// List response
+export const OrderRunListResponseSchema = z.object({
+    items: z.array(OrderRunSchema),
+    total: z.number(),
+    page: z.number(),
+    pageSize: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+// Query params for dispatch view (operation runs across open orders)
+export const DispatchListQuerySchema = z.object({
+    page: z.coerce.number().int().min(1).optional().default(1),
+    pageSize: z.coerce.number().int().min(1).max(100).optional().default(20),
+    status: OperationRunStatusEnum.optional(),
+    priority: OrderRunPriorityEnum.optional(),
+    search: z.string().optional(),
+    viewAs: z.string().optional(),
+    canWork: z
+        .union([z.literal("true"), z.literal("false")])
+        .transform((v) => v === "true")
+        .optional(),
+    clockedIn: z
+        .union([z.literal("true"), z.literal("false")])
+        .transform((v) => v === "true")
+        .optional(),
+});
+// Dispatch item = operation run with parent order/run context
+export const DispatchItemSchema = z.object({
+    id: z.number(),
+    orderKey: z.string(),
+    revNo: z.number(),
+    runNo: z.number(),
+    seqNo: z.number(),
+    title: z.string(),
+    workCenterKey: z.string().nullable(),
+    canWork: z.boolean(),
+    status: OperationRunStatusEnum,
+    priority: OrderRunPriorityEnum,
+    assignedTo: z.string().nullable(),
+    dueAt: z.string().nullable(),
+    createdAt: z.iso.datetime(),
+});
+export const DispatchListResponseSchema = z.object({
+    items: z.array(DispatchItemSchema),
+    total: z.number(),
+    page: z.number(),
+    pageSize: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actionTemplates: z.array(HateoasActionTemplateSchema).optional(),
+});

package/dist/order-types.js

@@ -0,0 +1,61 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+export const OrderStatusEnum = z.enum(["active", "archived"]);
+export const OrderStatus = OrderStatusEnum.enum;
+// Full order response shape
+export const OrderSchema = z.object({
+    id: z.number(),
+    key: z.string(),
+    description: z.string(),
+    status: OrderStatusEnum,
+    itemKey: z.string().nullable(),
+    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 order
+export const CreateOrderSchema = 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(""),
+    itemKey: z.string().max(100).optional(),
+})
+    .strict();
+// Input for updating an order
+export const UpdateOrderSchema = 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(),
+    status: OrderStatusEnum.optional(),
+    itemKey: z.string().max(100).nullable().optional(),
+})
+    .strict();
+// Query params for listing orders
+export const OrderListQuerySchema = z.object({
+    page: z.coerce.number().int().min(1).optional().default(1),
+    pageSize: z.coerce.number().int().min(1).max(100).optional().default(20),
+    status: z.enum(["active", "archived"]).optional(),
+    search: z.string().optional(),
+});
+// List response
+export const OrderListResponseSchema = z.object({
+    items: z.array(OrderSchema),
+    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/revision-diff-types.js

@@ -0,0 +1,55 @@
+import { z } from "zod/v4";
+// A single changed property
+export const PropertyChangeSchema = z.object({
+    field: z.string(),
+    from: z.union([z.string(), z.number(), z.boolean(), z.null()]),
+    to: z.union([z.string(), z.number(), z.boolean(), z.null()]),
+});
+export const DiffStatusEnum = z.enum([
+    "added",
+    "removed",
+    "modified",
+    "unchanged",
+]);
+// Field-level diff
+export const FieldDiffSchema = z.object({
+    seqNo: z.number(),
+    label: z.string(),
+    status: DiffStatusEnum,
+    changes: z.array(PropertyChangeSchema).optional(),
+});
+// Step-level diff
+export const StepDiffSchema = z.object({
+    seqNo: z.number(),
+    title: z.string(),
+    status: DiffStatusEnum,
+    changes: z.array(PropertyChangeSchema).optional(),
+    fields: z.array(FieldDiffSchema).optional(),
+});
+// Dependency diff
+export const DependencyDiffSchema = z.object({
+    predecessorSeqNo: z.number(),
+    predecessorTitle: z.string(),
+    status: z.enum(["added", "removed", "unchanged"]),
+});
+// Operation-level diff
+export const OperationDiffSchema = z.object({
+    seqNo: z.number(),
+    title: z.string(),
+    status: DiffStatusEnum,
+    changes: z.array(PropertyChangeSchema).optional(),
+    steps: z.array(StepDiffSchema).optional(),
+    dependencies: z.array(DependencyDiffSchema).optional(),
+});
+// Top-level diff response
+export const RevisionDiffResponseSchema = z.object({
+    fromRevNo: z.number(),
+    toRevNo: z.number(),
+    revisionChanges: z.array(PropertyChangeSchema),
+    operations: z.array(OperationDiffSchema),
+});
+// Query params
+export const RevisionDiffQuerySchema = z.object({
+    from: z.coerce.number().int().min(1),
+    to: z.coerce.number().int().min(1),
+});

package/dist/step-run-types.js

@@ -0,0 +1,148 @@
+import { z } from "zod/v4";
+import { HateoasActionSchema, HateoasActionTemplateSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+// Validation result for a field value
+export const FieldValidationSchema = z.object({
+    valid: z.boolean(),
+    error: z.string().optional(),
+});
+// Attachment metadata within a field value
+export const FieldAttachmentSchema = z.object({
+    id: z.string(),
+    filename: z.string(),
+    fileSize: z.number(),
+    downloadHref: z.string().optional(),
+});
+// Field value: string for scalar fields, string[] for array fields (type ends with "[]")
+// Coerce non-strings (e.g. numbers, booleans) to strings so callers don't
+// get an opaque "Invalid input" error when they send 2024 instead of "2024".
+const coercedString = z.coerce.string();
+export const FieldValueSchema = z.union([
+    z.array(coercedString),
+    coercedString,
+]);
+/** Human/AI-readable hint for the expected value format per field type. */
+export const VALUE_FORMAT_HINTS = {
+    string: "any text",
+    number: 'numeric string, e.g. "42" or "3.14"',
+    date: 'YYYY-MM-DD, e.g. "2024-06-15"',
+    datetime: 'YYYY-MM-DDTHH:mm, e.g. "2024-06-15T09:30"',
+    yesNo: '"Yes" or "No"',
+    checkbox: '"checked" or "" (empty string to uncheck)',
+    attachment: "managed by file upload endpoints, not set directly",
+};
+/** Return the API-facing type string, appending "[]" for array fields. */
+export function fieldTypeString(type, isArray) {
+    return isArray ? `${type}[]` : type;
+}
+/** Look up the valueFormat hint for a given field type (handles "[]" suffix). */
+export function getValueFormatHint(type) {
+    const isArray = type.endsWith("[]");
+    const baseType = isArray ? type.slice(0, -2) : type;
+    const hint = VALUE_FORMAT_HINTS[baseType] ?? "any text";
+    if (isArray) {
+        return `value must be a native JSON array (not a string), e.g. ["value1", "value2"]. Each element: ${hint}`;
+    }
+    return hint;
+}
+// A single field value entry (API response shape)
+export const FieldValueEntrySchema = z.object({
+    fieldId: z.number(),
+    fieldSeqNo: z.number(),
+    label: z.string(),
+    type: z.string(),
+    valueFormat: z.string(),
+    required: z.boolean(),
+    setIndex: z.number(),
+    value: FieldValueSchema,
+    attachments: z.array(FieldAttachmentSchema).optional(),
+    validation: FieldValidationSchema,
+});
+// Upload attachment response
+export const UploadAttachmentResponseSchema = z.object({
+    attachmentId: z.string(),
+    filename: z.string(),
+    fileSize: z.number(),
+});
+// Full step run response shape
+export const StepRunSchema = z.object({
+    id: z.number(),
+    operationRunId: z.number(),
+    stepId: z.number(),
+    seqNo: z.number(),
+    title: z.string(),
+    instructions: z.string(),
+    multiSet: z.boolean(),
+    completed: z.boolean(),
+    note: z.string().nullable(),
+    fieldCount: z.number().optional(),
+    fieldValues: z.array(FieldValueEntrySchema).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(),
+    _actionTemplates: z.array(HateoasActionTemplateSchema).optional(),
+});
+// Single field value update (setIndex is specified via URL path, not body)
+const coercedStringMax = z.coerce.string().max(2000);
+export const UpdateFieldValueSchema = z
+    .object({
+    value: z.union([z.array(coercedStringMax), coercedStringMax]),
+})
+    .strict();
+// Batch field value update (setIndex is specified via URL path, not body)
+export const BatchUpdateFieldValuesSchema = z
+    .object({
+    fieldValues: z.array(z.object({
+        fieldSeqNo: z.number().int(),
+        value: z.union([z.array(coercedStringMax), coercedStringMax]),
+    })),
+})
+    .strict();
+// Batch field value response
+export const BatchFieldValueResponseSchema = z.object({
+    items: z.array(FieldValueEntrySchema),
+    total: z.number(),
+});
+// Response for single field value update — field entry + step-level actions
+export const FieldValueUpdateResponseSchema = FieldValueEntrySchema.extend({
+    _actions: z.array(HateoasActionSchema).optional(),
+    _actionTemplates: z.array(HateoasActionTemplateSchema).optional(),
+});
+// Response for batch field value update — field entries + step-level actions
+export const BatchFieldValueUpdateResponseSchema = BatchFieldValueResponseSchema.extend({
+    _actions: z.array(HateoasActionSchema).optional(),
+    _actionTemplates: z.array(HateoasActionTemplateSchema).optional(),
+});
+// Response for deleting a field value set
+export const DeleteSetResponseSchema = z.object({
+    setCount: z.number(),
+    _actions: z.array(HateoasActionSchema).optional(),
+    _actionTemplates: z.array(HateoasActionTemplateSchema).optional(),
+});
+// Slim transition response (complete/reopen)
+export const StepRunTransitionSchema = z.object({
+    id: z.number(),
+    completed: z.boolean(),
+    note: z.string().nullable(),
+    updatedAt: z.iso.datetime(),
+    updatedBy: z.string(),
+    _actions: z.array(HateoasActionSchema).optional(),
+    _actionTemplates: z.array(HateoasActionTemplateSchema).optional(),
+});
+// Query params for listing step runs
+export const StepRunListQuerySchema = z.object({
+    includeFields: z
+        .union([z.literal("true"), z.literal("false")])
+        .transform((v) => v === "true")
+        .optional(),
+});
+// List response
+export const StepRunListResponseSchema = z.object({
+    items: z.array(StepRunSchema),
+    total: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});

package/dist/step-types.js

@@ -0,0 +1,51 @@
+import { z } from "zod/v4";
+import { FieldListResponseSchema } from "./field-types.js";
+import { HateoasActionSchema, HateoasLinkSchema, HateoasLinkTemplateSchema, } from "./hateoas-types.js";
+// Full step response shape
+export const StepSchema = z.object({
+    id: z.number(),
+    operationId: z.number(),
+    seqNo: z.number(),
+    title: z.string(),
+    instructions: z.string(),
+    multiSet: z.boolean(),
+    fieldCount: z.number().optional(),
+    createdAt: z.iso.datetime(),
+    createdBy: z.string(),
+    updatedAt: z.iso.datetime(),
+    updatedBy: z.string(),
+    fields: FieldListResponseSchema,
+    _links: z.array(HateoasLinkSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});
+// Input for creating a step
+export const CreateStepSchema = z
+    .object({
+    seqNo: z.number().int().min(1).optional(),
+    title: z.string().max(200).optional(),
+    instructions: z.string().max(10000).optional(),
+    multiSet: z.boolean().optional(),
+})
+    .strict();
+// Input for batch creating steps
+export const BatchCreateStepSchema = z.object({
+    items: z.array(CreateStepSchema).min(1).max(100),
+});
+// Input for updating a step
+export const UpdateStepSchema = z
+    .object({
+    seqNo: z.number().int().min(1).optional(),
+    title: z.string().max(200).optional(),
+    instructions: z.string().max(10000).optional(),
+    multiSet: z.boolean().optional(),
+})
+    .strict();
+// List response
+export const StepListResponseSchema = z.object({
+    items: z.array(StepSchema),
+    total: z.number(),
+    nextSeqNo: z.number(),
+    _links: z.array(HateoasLinkSchema),
+    _linkTemplates: z.array(HateoasLinkTemplateSchema).optional(),
+    _actions: z.array(HateoasActionSchema).optional(),
+});

package/dist/user-types.js

@@ -0,0 +1,79 @@
+import { z } from "zod/v4";
+export const ErpPermissionEnum = z.enum([
+    "erp_admin",
+    "order_planner",
+    "order_executor",
+    "order_manager",
+    "item_manager",
+]);
+export const ErpPermission = ErpPermissionEnum.enum;
+const urlSafeUsername = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[a-zA-Z0-9_-]+$/, "Must contain only letters, numbers, hyphens, and underscores");
+export const CreateUserSchema = z
+    .object({
+    username: urlSafeUsername,
+    password: z.string().min(6),
+})
+    .strict();
+export const UpdateUserSchema = z
+    .object({
+    username: urlSafeUsername.optional(),
+    password: z.string().min(6).optional(),
+})
+    .strict();
+export const GrantPermissionSchema = z
+    .object({
+    permission: ErpPermissionEnum,
+})
+    .strict();
+export const CreateAgentUserSchema = z
+    .object({
+    agentId: z.number().int(),
+})
+    .strict();
+export const ChangePasswordSchema = z
+    .object({
+    password: z.string().min(6),
+})
+    .strict();
+export const UserPermissionSchema = z.object({
+    permission: ErpPermissionEnum,
+    grantedAt: z.string(),
+    grantedBy: z.number().nullable(),
+    _actions: z.array(z.any()).optional(),
+});
+export const UserSchema = z.object({
+    id: z.number(),
+    username: z.string(),
+    isAgent: z.boolean(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    apiKey: z.string().nullable().optional(),
+    permissions: z.array(UserPermissionSchema),
+    _links: z.array(z.any()).optional(),
+    _actions: z.array(z.any()).optional(),
+});
+export const UserListItemSchema = z.object({
+    id: z.number(),
+    username: z.string(),
+    isAgent: z.boolean(),
+    createdAt: z.string(),
+    permissionCount: z.number(),
+});
+export const UserListResponseSchema = z.object({
+    items: z.array(UserListItemSchema),
+    total: z.number(),
+    page: z.number(),
+    pageSize: z.number(),
+    _links: z.array(z.any()).optional(),
+    _linkTemplates: z.array(z.any()).optional(),
+    _actions: z.array(z.any()).optional(),
+});
+export const UserListQuerySchema = z.object({
+    page: z.coerce.number().int().min(1).default(1),
+    pageSize: z.coerce.number().int().min(1).max(100).default(20),
+    search: z.string().optional(),
+});