@pksep/zod-shared 0.0.554 → 0.0.556

package/dist/material/schemas/type-material.schema.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeMaterialSchema = exports.TypeMaterialCharacteristicsSchema = void 0;
 const zod_1 = require("zod");
+const enum_1 = require("../enum/enum");
 const utils_1 = require("../../utils");
 const TypeMaterialCharacteristicsItemSchema = zod_1.z.object({
     edizmId: zod_1.z.number().int(),
@@ -15,12 +16,18 @@ exports.TypeMaterialCharacteristicsSchema = zod_1.z.object({
     wallThickness: TypeMaterialCharacteristicsItemSchema,
     outsideDiameter: TypeMaterialCharacteristicsItemSchema,
     thickness: TypeMaterialCharacteristicsItemSchema,
-    areaCrossSectional: TypeMaterialCharacteristicsItemSchema
+    areaCrossSectional: TypeMaterialCharacteristicsItemSchema,
+    acrossFlats: TypeMaterialCharacteristicsItemSchema,
+    massPerMeter: TypeMaterialCharacteristicsItemSchema
 });
 exports.TypeMaterialSchema = zod_1.z.object({
     id: zod_1.z.number().int().positive(),
     ban: zod_1.z.boolean(),
     name: zod_1.z.string(),
     characteristics: exports.TypeMaterialCharacteristicsSchema,
-    instance_type: zod_1.z.number().int().min(1).max(3)
+    instance_type: zod_1.z.number().int().min(1).max(3),
+    workpieceMassFormulaKey: zod_1.z
+        .nativeEnum(enum_1.WorkpieceMassFormulaKey)
+        .nullable()
+        .optional()
 });

package/dist/material/utils/workpiece-mass.js

@@ -173,17 +173,24 @@ exports.WORKPIECE_MASS_FORMULAS = [
         ]
     }
 ];
+const normalizeCharacteristicNumericValue = (value) => {
+    if (typeof value === 'number' && !Number.isNaN(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalizedValue = Number(value);
+        return !Number.isNaN(normalizedValue) ? normalizedValue : null;
+    }
+    return null;
+};
 const getMaterialCharacteristicValue = (context, key) => {
     var _a, _b;
     const item = (_b = (_a = context.material) === null || _a === void 0 ? void 0 : _a.characteristics) === null || _b === void 0 ? void 0 : _b[key];
-    return typeof (item === null || item === void 0 ? void 0 : item.znach) === 'number' && !Number.isNaN(item.znach)
-        ? item.znach
-        : null;
+    return normalizeCharacteristicNumericValue(item === null || item === void 0 ? void 0 : item.znach);
 };
 const getWorkpieceCharacteristicValue = (context, key) => {
     var _a;
-    const value = (_a = context.workpieceCharacterization) === null || _a === void 0 ? void 0 : _a[key];
-    return typeof value === 'number' && !Number.isNaN(value) ? value : null;
+    return normalizeCharacteristicNumericValue((_a = context.workpieceCharacterization) === null || _a === void 0 ? void 0 : _a[key]);
 };
 /**
  * Возвращаем первое осмысленное положительное значение.
@@ -216,7 +223,7 @@ const getPreparedWorkpieceValues = (context) => {
                 ? pickPreparedCharacteristicValue(getMaterialCharacteristicValue(context, characteristicKey), getWorkpieceCharacteristicValue(context, characteristicKey))
                 : pickPreparedCharacteristicValue(getWorkpieceCharacteristicValue(context, characteristicKey), getMaterialCharacteristicValue(context, characteristicKey));
     }
-    const density = getMaterialCharacteristicValue(context, 'density');
+    const density = pickPreparedCharacteristicValue(getWorkpieceCharacteristicValue(context, 'density'), getMaterialCharacteristicValue(context, 'density'));
     if (density !== null)
         result.density = density;
     const mass = getWorkpieceCharacteristicValue(context, 'mass');

package/dist/material/workpiece-mass.d.ts

@@ -0,0 +1,45 @@
+import { WorkpieceMassFormulaKey } from './enum/enum';
+import type { ModelMaterial } from './schemas/material.schema';
+import type { ModelTypeMaterial } from './schemas/type-material.schema';
+export type TWorkpieceMassVariableKey = 'density' | 'length' | 'width' | 'height' | 'thickness' | 'wallThickness' | 'outsideDiameter' | 'areaCrossSectional' | 'acrossFlats' | 'massPerMeter';
+export interface IWorkpieceMassFormulaVariable {
+    key: TWorkpieceMassVariableKey;
+    name: string;
+    source: 'material' | 'workpiece';
+    required: boolean;
+}
+export interface IWorkpieceMassFormula {
+    key: WorkpieceMassFormulaKey;
+    name: string;
+    description: string;
+    variables: IWorkpieceMassFormulaVariable[];
+}
+export type TResolvedWorkpieceMassVariables = Partial<Record<TWorkpieceMassVariableKey, number>>;
+export interface ICalculateWorkpieceMassContext {
+    typeMaterial: ModelTypeMaterial;
+    material: ModelMaterial;
+    workpieceCharacterization?: Record<string, number | null | undefined>;
+    workpieceMassFormulaKey?: WorkpieceMassFormulaKey;
+}
+export interface ICalculateWorkpieceMassResult {
+    formulaKey: WorkpieceMassFormulaKey;
+    mass: number;
+    variables: TResolvedWorkpieceMassVariables;
+}
+type TPreparedWorkpieceValues = Partial<Record<TWorkpieceMassVariableKey | 'mass' | 'trash', number>>;
+type TWorkpieceMassVariableResolver = (context: ICalculateWorkpieceMassContext, prepared: TPreparedWorkpieceValues) => number | null;
+type TWorkpieceMassCalculator = (vars: TResolvedWorkpieceMassVariables) => number;
+export declare const WORKPIECE_MASS_FORMULAS: IWorkpieceMassFormula[];
+/**
+ * Реестр источников значений переменных.
+ * Здесь описано, откуда брать каждую переменную под расчет массы заготовки.
+ */
+export declare const WORKPIECE_MASS_VARIABLE_RESOLVERS: Record<TWorkpieceMassVariableKey, TWorkpieceMassVariableResolver>;
+/**
+ * Реестр математических алгоритмов расчета.
+ * Здесь только математика, без поиска значений по моделям.
+ */
+export declare const WORKPIECE_MASS_CALCULATORS: Record<WorkpieceMassFormulaKey, TWorkpieceMassCalculator>;
+export declare const resolveWorkpieceMassVariables: (context: ICalculateWorkpieceMassContext, variableKeys: TWorkpieceMassVariableKey[]) => TResolvedWorkpieceMassVariables;
+export declare const calculateWorkpieceMassPreview: (context: ICalculateWorkpieceMassContext) => ICalculateWorkpieceMassResult | null;
+export {};

package/dist/material/workpiece-mass.js

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWorkpieceMassPreview = exports.resolveWorkpieceMassVariables = exports.WORKPIECE_MASS_CALCULATORS = exports.WORKPIECE_MASS_VARIABLE_RESOLVERS = exports.WORKPIECE_MASS_FORMULAS = void 0;
+const enum_1 = require("./enum/enum");
+const utils_1 = require("../utils");
+exports.WORKPIECE_MASS_FORMULAS = [
+    {
+        key: enum_1.WorkpieceMassFormulaKey.boundingBox,
+        name: 'Прямоугольная заготовка',
+        description: 'm = ρ * L * B * H',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            },
+            {
+                key: 'width',
+                name: 'Ширина',
+                source: 'workpiece',
+                required: true
+            },
+            {
+                key: 'height',
+                name: 'Высота',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.rectangularSection,
+        name: 'Прямоугольное сечение',
+        description: 'm = ρ * L * B * t',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            },
+            {
+                key: 'width',
+                name: 'Ширина',
+                source: 'workpiece',
+                required: true
+            },
+            {
+                key: 'thickness',
+                name: 'Толщина',
+                source: 'material',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.solidRoundSection,
+        name: 'Полнотелое круглое сечение',
+        description: 'm = ρ * π * D² / 4 * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'outsideDiameter',
+                name: 'Наружный диаметр',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.hollowRoundSection,
+        name: 'Полое круглое сечение',
+        description: 'm = ρ * π * t * (D - t) * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'outsideDiameter',
+                name: 'Наружный диаметр',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'wallThickness',
+                name: 'Толщина стенки',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.hollowProfileSection,
+        name: 'Полое профильное сечение',
+        description: 'm = ρ * (B * H - (B - 2t) * (H - 2t)) * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'width',
+                name: 'Ширина профиля',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'height',
+                name: 'Высота профиля',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'wallThickness',
+                name: 'Толщина стенки',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.hexSection,
+        name: 'Шестигранное сечение',
+        description: 'm = ρ * 0.866025 * S² * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'acrossFlats',
+                name: 'Размер под ключ',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.sectionArea,
+        name: 'По площади сечения',
+        description: 'm = ρ * A * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'areaCrossSectional',
+                name: 'Площадь поперечного сечения',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.linearMass,
+        name: 'По массе погонного метра',
+        description: 'm = q * L',
+        variables: [
+            {
+                key: 'massPerMeter',
+                name: 'Масса погонного метра',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    }
+];
+const getMaterialCharacteristicValue = (context, key) => {
+    var _a, _b;
+    const item = (_b = (_a = context.material) === null || _a === void 0 ? void 0 : _a.characteristics) === null || _b === void 0 ? void 0 : _b[key];
+    return typeof (item === null || item === void 0 ? void 0 : item.znach) === 'number' && !Number.isNaN(item.znach)
+        ? item.znach
+        : null;
+};
+const getWorkpieceCharacteristicValue = (context, key) => {
+    var _a;
+    const value = (_a = context.workpieceCharacterization) === null || _a === void 0 ? void 0 : _a[key];
+    return typeof value === 'number' && !Number.isNaN(value) ? value : null;
+};
+const getPreparedWorkpieceValues = (context) => {
+    var _a, _b, _c, _d;
+    const result = {};
+    const typeMaterialCharacteristics = ((_a = context.typeMaterial) === null || _a === void 0 ? void 0 : _a.characteristics) || {};
+    for (const characteristicKey of Object.keys(typeMaterialCharacteristics)) {
+        const characteristicMode = (_b = typeMaterialCharacteristics[characteristicKey]) === null || _b === void 0 ? void 0 : _b.znach;
+        if (!characteristicMode)
+            continue;
+        result[characteristicKey] =
+            characteristicMode === utils_1.TypeMaterialCharZnachEnum.permanent
+                ? ((_c = getMaterialCharacteristicValue(context, characteristicKey)) !== null && _c !== void 0 ? _c : undefined)
+                : ((_d = getWorkpieceCharacteristicValue(context, characteristicKey)) !== null && _d !== void 0 ? _d : undefined);
+    }
+    const density = getMaterialCharacteristicValue(context, 'density');
+    if (density !== null)
+        result.density = density;
+    const mass = getWorkpieceCharacteristicValue(context, 'mass');
+    if (mass !== null)
+        result.mass = mass;
+    const trash = getWorkpieceCharacteristicValue(context, 'trash');
+    if (trash !== null)
+        result.trash = trash;
+    return result;
+};
+const getPreparedValue = (prepared, key) => {
+    const value = prepared[key];
+    return typeof value === 'number' && !Number.isNaN(value) ? value : null;
+};
+/**
+ * Реестр источников значений переменных.
+ * Здесь описано, откуда брать каждую переменную под расчет массы заготовки.
+ */
+exports.WORKPIECE_MASS_VARIABLE_RESOLVERS = {
+    density: (context, prepared) => {
+        var _a;
+        return (_a = getPreparedValue(prepared, 'density')) !== null && _a !== void 0 ? _a : getMaterialCharacteristicValue(context, 'density');
+    },
+    length: (_context, prepared) => getPreparedValue(prepared, 'length'),
+    width: (_context, prepared) => getPreparedValue(prepared, 'width'),
+    height: (_context, prepared) => getPreparedValue(prepared, 'height'),
+    thickness: (_context, prepared) => getPreparedValue(prepared, 'thickness'),
+    wallThickness: (_context, prepared) => getPreparedValue(prepared, 'wallThickness'),
+    outsideDiameter: (_context, prepared) => getPreparedValue(prepared, 'outsideDiameter'),
+    areaCrossSectional: (_context, prepared) => getPreparedValue(prepared, 'areaCrossSectional'),
+    // TODO: добавить поле в model/type_material/material/workpiece_characterization
+    acrossFlats: (context, prepared) => {
+        var _a;
+        return (_a = getPreparedValue(prepared, 'acrossFlats')) !== null && _a !== void 0 ? _a : getMaterialCharacteristicValue(context, 'acrossFlats');
+    },
+    // TODO: добавить поле в material.characteristics или отдельную модель
+    massPerMeter: (context, prepared) => {
+        var _a;
+        return (_a = getPreparedValue(prepared, 'massPerMeter')) !== null && _a !== void 0 ? _a : getMaterialCharacteristicValue(context, 'massPerMeter');
+    }
+};
+const getRequiredVar = (vars, key) => {
+    const value = vars[key];
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        throw new Error(`Не заполнена переменная "${key}" для расчета массы заготовки`);
+    }
+    return value;
+};
+/**
+ * Реестр математических алгоритмов расчета.
+ * Здесь только математика, без поиска значений по моделям.
+ */
+exports.WORKPIECE_MASS_CALCULATORS = {
+    [enum_1.WorkpieceMassFormulaKey.boundingBox]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const length = getRequiredVar(vars, 'length');
+        const width = getRequiredVar(vars, 'width');
+        const height = getRequiredVar(vars, 'height');
+        return density * length * width * height;
+    },
+    [enum_1.WorkpieceMassFormulaKey.rectangularSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const length = getRequiredVar(vars, 'length');
+        const width = getRequiredVar(vars, 'width');
+        const thickness = getRequiredVar(vars, 'thickness');
+        return density * length * width * thickness;
+    },
+    [enum_1.WorkpieceMassFormulaKey.solidRoundSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const outsideDiameter = getRequiredVar(vars, 'outsideDiameter');
+        const length = getRequiredVar(vars, 'length');
+        return (density * Math.PI * Math.pow(outsideDiameter, 2) * length) / 4;
+    },
+    [enum_1.WorkpieceMassFormulaKey.hollowRoundSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const outsideDiameter = getRequiredVar(vars, 'outsideDiameter');
+        const wallThickness = getRequiredVar(vars, 'wallThickness');
+        const length = getRequiredVar(vars, 'length');
+        return (density *
+            Math.PI *
+            wallThickness *
+            (outsideDiameter - wallThickness) *
+            length);
+    },
+    [enum_1.WorkpieceMassFormulaKey.hollowProfileSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const width = getRequiredVar(vars, 'width');
+        const height = getRequiredVar(vars, 'height');
+        const wallThickness = getRequiredVar(vars, 'wallThickness');
+        const length = getRequiredVar(vars, 'length');
+        return (density *
+            (width * height -
+                (width - 2 * wallThickness) * (height - 2 * wallThickness)) *
+            length);
+    },
+    [enum_1.WorkpieceMassFormulaKey.hexSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const acrossFlats = getRequiredVar(vars, 'acrossFlats');
+        const length = getRequiredVar(vars, 'length');
+        return density * 0.866025 * Math.pow(acrossFlats, 2) * length;
+    },
+    [enum_1.WorkpieceMassFormulaKey.sectionArea]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const areaCrossSectional = getRequiredVar(vars, 'areaCrossSectional');
+        const length = getRequiredVar(vars, 'length');
+        return density * areaCrossSectional * length;
+    },
+    [enum_1.WorkpieceMassFormulaKey.linearMass]: vars => {
+        const massPerMeter = getRequiredVar(vars, 'massPerMeter');
+        const length = getRequiredVar(vars, 'length');
+        return massPerMeter * length;
+    }
+};
+const resolveWorkpieceMassVariables = (context, variableKeys) => {
+    var _a;
+    const prepared = getPreparedWorkpieceValues(context);
+    const result = {};
+    for (const key of variableKeys) {
+        result[key] =
+            (_a = exports.WORKPIECE_MASS_VARIABLE_RESOLVERS[key](context, prepared)) !== null && _a !== void 0 ? _a : undefined;
+    }
+    return result;
+};
+exports.resolveWorkpieceMassVariables = resolveWorkpieceMassVariables;
+const calculateWorkpieceMassPreview = (context) => {
+    var _a;
+    const formulaKey = context.workpieceMassFormulaKey ||
+        ((_a = context.typeMaterial) === null || _a === void 0 ? void 0 : _a.workpieceMassFormulaKey) ||
+        null;
+    if (!formulaKey)
+        return null;
+    const formula = exports.WORKPIECE_MASS_FORMULAS.find(currentFormula => currentFormula.key === formulaKey);
+    if (!formula) {
+        throw new Error(`Формула расчета массы заготовки "${formulaKey}" не найдена`);
+    }
+    const variables = (0, exports.resolveWorkpieceMassVariables)(context, formula.variables.map(variable => variable.key));
+    return {
+        formulaKey,
+        mass: exports.WORKPIECE_MASS_CALCULATORS[formulaKey](variables),
+        variables
+    };
+};
+exports.calculateWorkpieceMassPreview = calculateWorkpieceMassPreview;

package/dist/metaloworking/schemas/metaloworking-coming.schema.d.ts

@@ -36,9 +36,9 @@ export declare const MetaloworkingComingSchema: z.ZodObject<{
     wokrek_id: number;
     designation?: string | undefined;
     description?: string | undefined;
+    name?: string | undefined;
     id?: number | null | undefined;
     number_order?: string | undefined;
-    name?: string | undefined;
     ava_path?: string | undefined;
     detal_id?: number | null | undefined;
     shipment_id?: number | null | undefined;
@@ -56,9 +56,9 @@ export declare const MetaloworkingComingSchema: z.ZodObject<{
     ban?: boolean | undefined;
     designation?: string | undefined;
     description?: string | undefined;
+    name?: string | undefined;
     id?: number | null | undefined;
     number_order?: string | undefined;
-    name?: string | undefined;
     ava_path?: string | undefined;
     detal_id?: number | null | undefined;
     shipment_id?: number | null | undefined;

package/dist/moving/schemas/moving.schema.d.ts

@@ -131,8 +131,8 @@ export declare const MovingSchema: z.ZodObject<{
             cbed: import("../..").CbedRelativeType[];
             designation: string | null;
             description: string | null;
-            id: number;
             name: string;
+            id: number;
             calculate_needs_time: Date | null;
             entity_children_need_time: Date | null;
             min_remaining: number;
@@ -162,8 +162,8 @@ export declare const MovingSchema: z.ZodObject<{
         }, {
             designation: string | null;
             description: string | null;
-            id: number;
             name: string;
+            id: number;
             ava_path: string | null;
             parametrs: import("../..").CbedParametrsField | null;
             characteristic: import("../..").CbedCharacteristicField | null;
@@ -606,8 +606,8 @@ export declare const MovingSchema: z.ZodObject<{
             cbed: import("../..").CbedRelativeType[];
             designation: string | null;
             description: string | null;
-            id: number;
             name: string;
+            id: number;
             calculate_needs_time: Date | null;
             entity_children_need_time: Date | null;
             min_remaining: number;
@@ -800,8 +800,8 @@ export declare const MovingSchema: z.ZodObject<{
         cbeds: {
             designation: string | null;
             description: string | null;
-            id: number;
             name: string;
+            id: number;
             ava_path: string | null;
             parametrs: import("../..").CbedParametrsField | null;
             characteristic: import("../..").CbedCharacteristicField | null;
@@ -1095,8 +1095,8 @@ export declare const MovingSchema: z.ZodObject<{
             cbed: import("../..").CbedRelativeType[];
             designation: string | null;
             description: string | null;
-            id: number;
             name: string;
+            id: number;
             calculate_needs_time: Date | null;
             entity_children_need_time: Date | null;
             min_remaining: number;
@@ -1317,8 +1317,8 @@ export declare const MovingSchema: z.ZodObject<{
         cbeds: {
             designation: string | null;
             description: string | null;
-            id: number;
             name: string;
+            id: number;
             ava_path: string | null;
             parametrs: import("../..").CbedParametrsField | null;
             characteristic: import("../..").CbedCharacteristicField | null;

package/dist/operations/dto/get-type-operation-by-id.dto.d.ts

@@ -2,15 +2,15 @@ import z from 'zod';
 import { ModelIncludeForTypeOperation } from '../enums/enums';
 export declare const GetTypeOperationByIdDtoZod: z.ZodObject<{
     id: z.ZodNumber;
-    attributes: z.ZodOptional<z.ZodArray<z.ZodEnum<["id", "name", "preTime", "helperTime", "mainTime", "cpu", "square", "list", "workStartCalcType", "countWorking"]>, "many">>;
+    attributes: z.ZodOptional<z.ZodArray<z.ZodEnum<["name", "id", "preTime", "helperTime", "mainTime", "cpu", "square", "list", "workStartCalcType", "countWorking"]>, "many">>;
     modelInclude: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ModelIncludeForTypeOperation>, "many">>;
 }, "strip", z.ZodTypeAny, {
     id: number;
-    attributes?: ("id" | "name" | "preTime" | "helperTime" | "mainTime" | "cpu" | "square" | "list" | "workStartCalcType" | "countWorking")[] | undefined;
+    attributes?: ("name" | "id" | "preTime" | "helperTime" | "mainTime" | "cpu" | "square" | "list" | "workStartCalcType" | "countWorking")[] | undefined;
     modelInclude?: ModelIncludeForTypeOperation[] | undefined;
 }, {
     id: number;
-    attributes?: ("id" | "name" | "preTime" | "helperTime" | "mainTime" | "cpu" | "square" | "list" | "workStartCalcType" | "countWorking")[] | undefined;
+    attributes?: ("name" | "id" | "preTime" | "helperTime" | "mainTime" | "cpu" | "square" | "list" | "workStartCalcType" | "countWorking")[] | undefined;
     modelInclude?: ModelIncludeForTypeOperation[] | undefined;
 }>;
 export type GetTypeOperationByIdDtoType = z.TypeOf<typeof GetTypeOperationByIdDtoZod>;

package/dist/operations/dto/update-type-operation.dto.d.ts

@@ -19,8 +19,8 @@ export declare const UpdateTypeOperationSchema: z.ZodObject<{
     workStartCalcType: z.ZodDefault<z.ZodNativeEnum<typeof WorkStartCalcType>>;
 }, "strip", z.ZodTypeAny, {
     metaloworking: boolean;
-    id: number;
     name: string;
+    id: number;
     preTime: boolean;
     helperTime: boolean;
     mainTime: boolean;
@@ -36,8 +36,8 @@ export declare const UpdateTypeOperationSchema: z.ZodObject<{
     users?: any;
 }, {
     metaloworking: boolean;
-    id: number;
     name: string;
+    id: number;
     preTime: boolean;
     helperTime: boolean;
     mainTime: boolean;