@pksep/zod-shared 0.0.490

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PInventarySchema = void 0;
+const zod_1 = require("zod");
+const inventary_pt_schema_1 = require("./inventary-pt.schema");
+const inventary_schema_1 = require("./inventary.schema");
+exports.PInventarySchema = zod_1.z.object({
+    id: zod_1.z.number().int().positive(),
+    name: zod_1.z.string(),
+    pt_inventary: zod_1.z.array(inventary_pt_schema_1.PTInventarySchema),
+    inventary: zod_1.z.array(inventary_schema_1.InventarySchema)
+});

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

@@ -0,0 +1,3 @@
+import { z, ZodType } from 'zod';
+export declare const InventarySchema: ZodType;
+export type ModelInventary = z.infer<typeof InventarySchema>;

package/dist/inventary/schemas/inventary.schema.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventarySchema = void 0;
+const zod_1 = require("zod");
+const inventary_type_schema_1 = require("./inventary-type.schema");
+const document_1 = require("../../document");
+const action_1 = require("../../action");
+const provider_1 = require("../../provider");
+const deliveries_1 = require("../../deliveries");
+exports.InventarySchema = zod_1.z.object({
+    id: zod_1.z.number().int().positive(),
+    name: zod_1.z.string(),
+    quantity: zod_1.z.number().int().default(0),
+    price: zod_1.z.number().int().default(0),
+    shipments_kolvo: zod_1.z.number().int().default(0),
+    ban: zod_1.z.boolean().default(false),
+    responsible_id: zod_1.z.number().int().nullish(),
+    delivery_time: zod_1.z.number().int().nullish(),
+    delivery_ordered: zod_1.z.number().int().default(0),
+    mount_used: zod_1.z.number().int().nullish(),
+    min_remaining: zod_1.z.number().int().default(0),
+    description: zod_1.z.string().nullish(),
+    attention: zod_1.z.boolean().default(false),
+    providers: zod_1.z.array(provider_1.ProvidersSchema).optional(),
+    parent_t_id: zod_1.z.number().int(),
+    parent_type: zod_1.z.array(inventary_type_schema_1.PInventarySchema).optional(),
+    documents: zod_1.z.array(document_1.DocumentsSchema).optional(),
+    deliveries: zod_1.z.array(deliveries_1.DeliveriesSchema).optional(),
+    parent_pt_id: zod_1.z.number().int(),
+    parent_pt: zod_1.z.custom().optional(),
+    actions: zod_1.z.array(action_1.ActionsSchema).optional()
+});

package/dist/marks/dto/change-mark-quantity.dto.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+export declare const changeMarkQuantitySchema: z.ZodObject<{
+    dto: z.ZodObject<{
+        dateBuild: z.ZodAny;
+        assembleKitId: z.ZodOptional<z.ZodNumber>;
+        kol: z.ZodNumber;
+        description: z.ZodString;
+        userId: z.ZodNumber;
+        operId: z.ZodNumber;
+        assembleId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        metaloworkingId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        brak: z.ZodBoolean;
+        executionTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        operationExecutionTime: z.ZodAny;
+        productionTaskId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        userId: number;
+        description: string;
+        kol: number;
+        operId: number;
+        brak: boolean;
+        dateBuild?: any;
+        assembleKitId?: number | undefined;
+        assembleId?: number | null | undefined;
+        metaloworkingId?: number | null | undefined;
+        executionTime?: number | null | undefined;
+        operationExecutionTime?: any;
+        productionTaskId?: number | null | undefined;
+    }, {
+        userId: number;
+        description: string;
+        kol: number;
+        operId: number;
+        brak: boolean;
+        dateBuild?: any;
+        assembleKitId?: number | undefined;
+        assembleId?: number | null | undefined;
+        metaloworkingId?: number | null | undefined;
+        executionTime?: number | null | undefined;
+        operationExecutionTime?: any;
+        productionTaskId?: number | null | undefined;
+    }>;
+    userId: z.ZodNumber;
+    transaction: z.ZodAny;
+    relativeActionId: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    markId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    userId: number;
+    dto: {
+        userId: number;
+        description: string;
+        kol: number;
+        operId: number;
+        brak: boolean;
+        dateBuild?: any;
+        assembleKitId?: number | undefined;
+        assembleId?: number | null | undefined;
+        metaloworkingId?: number | null | undefined;
+        executionTime?: number | null | undefined;
+        operationExecutionTime?: any;
+        productionTaskId?: number | null | undefined;
+    };
+    markId: number;
+    transaction?: any;
+    relativeActionId?: number | null | undefined;
+}, {
+    userId: number;
+    dto: {
+        userId: number;
+        description: string;
+        kol: number;
+        operId: number;
+        brak: boolean;
+        dateBuild?: any;
+        assembleKitId?: number | undefined;
+        assembleId?: number | null | undefined;
+        metaloworkingId?: number | null | undefined;
+        executionTime?: number | null | undefined;
+        operationExecutionTime?: any;
+        productionTaskId?: number | null | undefined;
+    };
+    markId: number;
+    transaction?: any;
+    relativeActionId?: number | null | undefined;
+}>;
+export type ChangeMarkQuantityDto = z.infer<typeof changeMarkQuantitySchema>;

package/dist/marks/dto/change-mark-quantity.dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changeMarkQuantitySchema = void 0;
+const zod_1 = require("zod");
+const create_mark_dto_1 = require("./create-mark.dto");
+exports.changeMarkQuantitySchema = zod_1.z.object({
+    dto: create_mark_dto_1.createMarkSchemaDto,
+    userId: zod_1.z.number().int().nonnegative(),
+    transaction: zod_1.z.any(),
+    relativeActionId: zod_1.z.number().optional().nullable(),
+    markId: zod_1.z.number()
+});

package/dist/marks/dto/create-mark.dto.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const createMarkSchemaDto: z.ZodObject<{
+    dateBuild: z.ZodAny;
+    assembleKitId: z.ZodOptional<z.ZodNumber>;
+    kol: z.ZodNumber;
+    description: z.ZodString;
+    userId: z.ZodNumber;
+    operId: z.ZodNumber;
+    assembleId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    metaloworkingId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    brak: z.ZodBoolean;
+    executionTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    operationExecutionTime: z.ZodAny;
+    productionTaskId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    userId: number;
+    description: string;
+    kol: number;
+    operId: number;
+    brak: boolean;
+    dateBuild?: any;
+    assembleKitId?: number | undefined;
+    assembleId?: number | null | undefined;
+    metaloworkingId?: number | null | undefined;
+    executionTime?: number | null | undefined;
+    operationExecutionTime?: any;
+    productionTaskId?: number | null | undefined;
+}, {
+    userId: number;
+    description: string;
+    kol: number;
+    operId: number;
+    brak: boolean;
+    dateBuild?: any;
+    assembleKitId?: number | undefined;
+    assembleId?: number | null | undefined;
+    metaloworkingId?: number | null | undefined;
+    executionTime?: number | null | undefined;
+    operationExecutionTime?: any;
+    productionTaskId?: number | null | undefined;
+}>;
+export type CreateMarkDto = z.infer<typeof createMarkSchemaDto>;

package/dist/marks/dto/create-mark.dto.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMarkSchemaDto = void 0;
+const zod_1 = require("zod");
+exports.createMarkSchemaDto = zod_1.z.object({
+    dateBuild: zod_1.z.any(),
+    assembleKitId: zod_1.z.number().optional(),
+    kol: zod_1.z.number().nonnegative(),
+    description: zod_1.z.string(),
+    userId: zod_1.z.number().int().nonnegative(),
+    operId: zod_1.z.number().int().nonnegative(),
+    assembleId: zod_1.z.number().nullish(),
+    metaloworkingId: zod_1.z.number().nullish(),
+    brak: zod_1.z.boolean(),
+    executionTime: zod_1.z.number().nullish(),
+    operationExecutionTime: zod_1.z.any(),
+    productionTaskId: zod_1.z.number().nullish()
+});

package/dist/marks/dto/cut-marks.dto.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { IzdType } from '../../utils';
+export declare const cutMarksSchemaDto: z.ZodObject<{
+    entityId: z.ZodNumber;
+    entityType: z.ZodNativeEnum<typeof IzdType>;
+    userId: z.ZodOptional<z.ZodNumber>;
+    relativeActionId: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    transaction: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    entityId: number;
+    entityType: IzdType;
+    userId?: number | undefined;
+    transaction?: any;
+    relativeActionId?: number | null | undefined;
+}, {
+    entityId: number;
+    entityType: IzdType;
+    userId?: number | undefined;
+    transaction?: any;
+    relativeActionId?: number | null | undefined;
+}>;
+export type CutMarkDto = z.infer<typeof cutMarksSchemaDto>;

package/dist/marks/dto/cut-marks.dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cutMarksSchemaDto = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.cutMarksSchemaDto = zod_1.z.object({
+    entityId: zod_1.z.number(),
+    entityType: zod_1.z.nativeEnum(utils_1.IzdType),
+    userId: zod_1.z.number().optional(),
+    relativeActionId: zod_1.z.number().optional().nullable(),
+    transaction: zod_1.z.any().optional()
+});

package/dist/marks/dto/get-mark-for-modal.dto.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { ProductionOperationType } from '../../utils';
+export declare const getMarkForModalSchemaDto: z.ZodObject<{
+    id: z.ZodNumber;
+    operationId: z.ZodNumber;
+    typeIzd: z.ZodNativeEnum<typeof ProductionOperationType>;
+    isIncludeBan: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    operationId: number;
+    typeIzd: ProductionOperationType;
+    isIncludeBan: boolean | null;
+}, {
+    id: number;
+    operationId: number;
+    typeIzd: ProductionOperationType;
+    isIncludeBan?: boolean | null | undefined;
+}>;
+export type GetMarkForModalDto = z.infer<typeof getMarkForModalSchemaDto>;

package/dist/marks/dto/get-mark-for-modal.dto.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarkForModalSchemaDto = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.getMarkForModalSchemaDto = zod_1.z.object({
+    id: zod_1.z.number().int().nonnegative(),
+    operationId: zod_1.z.number().int().nonnegative(),
+    typeIzd: zod_1.z.nativeEnum(utils_1.ProductionOperationType),
+    isIncludeBan: zod_1.z.boolean().nullish().default(false)
+});

package/dist/marks/dto/get-result-work.dto.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const getResultWorkingPaginationSchemaDto: z.ZodObject<{
+    page: z.ZodNumber;
+    responsibleUserIds: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    selectTypeOperation: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    searchString: z.ZodOptional<z.ZodString>;
+    dateRange: z.ZodObject<{
+        start: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        end: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    }, {
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    dateRange: {
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    };
+    responsibleUserIds?: number[] | undefined;
+    selectTypeOperation?: number | null | undefined;
+    searchString?: string | undefined;
+}, {
+    page: number;
+    dateRange: {
+        start?: string | null | undefined;
+        end?: string | null | undefined;
+    };
+    responsibleUserIds?: number[] | undefined;
+    selectTypeOperation?: number | null | undefined;
+    searchString?: string | undefined;
+}>;
+export type GetResultWorkingPaginationDto = z.infer<typeof getResultWorkingPaginationSchemaDto>;

package/dist/marks/dto/get-result-work.dto.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResultWorkingPaginationSchemaDto = void 0;
+const zod_1 = require("zod");
+exports.getResultWorkingPaginationSchemaDto = zod_1.z.object({
+    page: zod_1.z.number().int().nonnegative(),
+    responsibleUserIds: zod_1.z.array(zod_1.z.number()).optional(),
+    selectTypeOperation: zod_1.z.number().int().nullish(),
+    searchString: zod_1.z.string().optional(),
+    dateRange: zod_1.z.object({
+        start: zod_1.z.string().nullable().optional(),
+        end: zod_1.z.string().nullable().optional()
+    })
+});

package/dist/marks/dto/update-mark.dto.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const updateMarkSchemaDto: z.ZodObject<{
+    id: z.ZodNumber;
+    dateBuild: z.ZodString;
+    kol: z.ZodNumber;
+    description: z.ZodString;
+    userId: z.ZodNumber;
+    operId: z.ZodNumber;
+    brak: z.ZodBoolean;
+    executionTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    operationExecutionTime: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, any, string | null | undefined>;
+}, "strip", z.ZodTypeAny, {
+    userId: number;
+    description: string;
+    id: number;
+    dateBuild: string;
+    kol: number;
+    operId: number;
+    brak: boolean;
+    executionTime?: number | null | undefined;
+    operationExecutionTime?: any;
+}, {
+    userId: number;
+    description: string;
+    id: number;
+    dateBuild: string;
+    kol: number;
+    operId: number;
+    brak: boolean;
+    executionTime?: number | null | undefined;
+    operationExecutionTime?: string | null | undefined;
+}>;
+export type UpdateMarkDto = z.infer<typeof updateMarkSchemaDto>;

package/dist/marks/dto/update-mark.dto.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateMarkSchemaDto = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.updateMarkSchemaDto = zod_1.z.object({
+    id: zod_1.z.number().int().nonnegative(),
+    dateBuild: zod_1.z.string(),
+    kol: zod_1.z.number().nonnegative(),
+    description: zod_1.z.string(),
+    userId: zod_1.z.number().int().nonnegative(),
+    operId: zod_1.z.number().int().nonnegative(),
+    brak: zod_1.z.boolean(),
+    executionTime: zod_1.z.number().nullish(),
+    operationExecutionTime: zod_1.z
+        .string()
+        .nullish()
+        .transform(value => {
+        return (0, utils_1.parseParamsOrBody)({ value }, null);
+    })
+});

package/dist/marks/enums/enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum MarkStatusEnums {
+    active = "active",
+    archive = "archive",
+    shipped = "shipped",
+    fault = "fault"
+}

package/dist/marks/enums/enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkStatusEnums = void 0;
+var MarkStatusEnums;
+(function (MarkStatusEnums) {
+    MarkStatusEnums["active"] = "active";
+    MarkStatusEnums["archive"] = "archive";
+    MarkStatusEnums["shipped"] = "shipped";
+    MarkStatusEnums["fault"] = "fault";
+})(MarkStatusEnums || (exports.MarkStatusEnums = MarkStatusEnums = {}));

package/dist/marks/index.d.ts

@@ -0,0 +1,10 @@
+export * from './dto/create-mark.dto';
+export * from './dto/get-mark-for-modal.dto';
+export * from './dto/get-result-work.dto';
+export * from './dto/update-mark.dto';
+export * from './enums/enum';
+export * from './schemas/marks.schema';
+export * from './type/type';
+export * from './interfaces/interface';
+export * from './dto/change-mark-quantity.dto';
+export * from './dto/cut-marks.dto';

package/dist/marks/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dto/create-mark.dto"), exports);
+__exportStar(require("./dto/get-mark-for-modal.dto"), exports);
+__exportStar(require("./dto/get-result-work.dto"), exports);
+__exportStar(require("./dto/update-mark.dto"), exports);
+__exportStar(require("./enums/enum"), exports);
+__exportStar(require("./schemas/marks.schema"), exports);
+__exportStar(require("./type/type"), exports);
+__exportStar(require("./interfaces/interface"), exports);
+__exportStar(require("./dto/change-mark-quantity.dto"), exports);
+__exportStar(require("./dto/cut-marks.dto"), exports);

package/dist/marks/interfaces/interface.d.ts

@@ -0,0 +1,7 @@
+export interface IMarksCreationAttrs {
+    readonly date_build: string;
+    readonly kol: number;
+    readonly user_id: number;
+    readonly oper_id: number;
+    readonly brak: boolean;
+}

package/dist/marks/interfaces/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { MarkStatusEnums } from '../enums/enum';
+import { ModelUser } from '../../user';
+import { ModelAssembleKit } from '../../assemble-kit';
+import { ModelAssemble } from '../../assemble';
+import { ModelMetaloworking } from '../../metaloworking';
+import { ModelOperation } from '../../operations';
+import { ModelProductionTask } from '../../production-tasks';
+export declare const marksSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    date_build: z.ZodString;
+    kol: z.ZodNumber;
+    quantity_shipped: z.ZodNumber;
+    brak: z.ZodBoolean;
+    ban: z.ZodBoolean;
+    status: z.ZodNativeEnum<typeof MarkStatusEnums>;
+    description: z.ZodOptional<z.ZodString>;
+    execution_time: z.ZodNumber;
+    operation_execution_time: z.ZodOptional<z.ZodObject<{
+        helperTime: z.ZodNumber;
+        mainTime: z.ZodNumber;
+        preTime: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        preTime: number;
+        helperTime: number;
+        mainTime: number;
+    }, {
+        preTime: number;
+        helperTime: number;
+        mainTime: number;
+    }>>;
+    user_id: z.ZodNumber;
+    assemble_id: z.ZodNumber;
+    metaloworking_id: z.ZodNumber;
+    oper_id: z.ZodNumber;
+    assemble_kit_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    production_task_id: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: MarkStatusEnums;
+    ban: boolean;
+    id: number;
+    kol: number;
+    brak: boolean;
+    user_id: number;
+    metaloworking_id: number;
+    production_task_id: number | null;
+    date_build: string;
+    quantity_shipped: number;
+    execution_time: number;
+    assemble_id: number;
+    oper_id: number;
+    description?: string | undefined;
+    operation_execution_time?: {
+        preTime: number;
+        helperTime: number;
+        mainTime: number;
+    } | undefined;
+    assemble_kit_id?: number | null | undefined;
+}, {
+    status: MarkStatusEnums;
+    ban: boolean;
+    id: number;
+    kol: number;
+    brak: boolean;
+    user_id: number;
+    metaloworking_id: number;
+    production_task_id: number | null;
+    date_build: string;
+    quantity_shipped: number;
+    execution_time: number;
+    assemble_id: number;
+    oper_id: number;
+    description?: string | undefined;
+    operation_execution_time?: {
+        preTime: number;
+        helperTime: number;
+        mainTime: number;
+    } | undefined;
+    assemble_kit_id?: number | null | undefined;
+}>;
+export type ModelMarks = z.infer<typeof marksSchema> & {
+    user?: ModelUser;
+    assembleKit?: ModelAssembleKit;
+    assemble?: ModelAssemble;
+    metalloworking?: ModelMetaloworking;
+    operation?: ModelOperation;
+    ProductionTask?: ModelProductionTask;
+};

package/dist/marks/schemas/marks.schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marksSchema = void 0;
+const zod_1 = require("zod");
+const enum_1 = require("../enums/enum");
+exports.marksSchema = zod_1.z.object({
+    id: zod_1.z.number().int().nonnegative(),
+    date_build: zod_1.z.string(),
+    kol: zod_1.z.number().nonnegative(),
+    quantity_shipped: zod_1.z.number().nonnegative(),
+    brak: zod_1.z.boolean(),
+    ban: zod_1.z.boolean(),
+    status: zod_1.z.nativeEnum(enum_1.MarkStatusEnums),
+    description: zod_1.z.string().optional(),
+    execution_time: zod_1.z.number().nonnegative(),
+    operation_execution_time: zod_1.z
+        .object({
+        helperTime: zod_1.z.number().nonnegative(),
+        mainTime: zod_1.z.number().nonnegative(),
+        preTime: zod_1.z.number().nonnegative()
+    })
+        .optional(),
+    user_id: zod_1.z.number().int().nonnegative(),
+    assemble_id: zod_1.z.number().int().nonnegative(),
+    metaloworking_id: zod_1.z.number().int().nonnegative(),
+    oper_id: zod_1.z.number().int().nonnegative(),
+    assemble_kit_id: zod_1.z.number().nullish(),
+    production_task_id: zod_1.z.number().nullable()
+});

package/dist/marks/type/type.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { ActionEntityTypes } from '../../action';
+import { ProductionOperationType } from '../../utils';
+export declare const getMarkForOperationTypeSchema: z.ZodObject<{
+    kolvo_create: z.ZodNumber;
+    kolvo_shipments: z.ZodNumber;
+    id: z.ZodNumber;
+    current: z.ZodAny;
+    after: z.ZodAny;
+    before: z.ZodAny;
+    operation_id: z.ZodNumber;
+    tOperationId: z.ZodNumber;
+    entityName: z.ZodString;
+    tech_process: z.ZodAny;
+    entityId: z.ZodNumber;
+    typeIzd: z.ZodNativeEnum<typeof ProductionOperationType>;
+    entityDesignation: z.ZodString;
+    entityType: z.ZodUnion<[z.ZodLiteral<ActionEntityTypes.product>, z.ZodLiteral<ActionEntityTypes.cbed>, z.ZodLiteral<ActionEntityTypes.detal>]>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    typeIzd: ProductionOperationType;
+    entityId: number;
+    operation_id: number;
+    tOperationId: number;
+    kolvo_create: number;
+    kolvo_shipments: number;
+    entityType: ActionEntityTypes.product | ActionEntityTypes.cbed | ActionEntityTypes.detal;
+    entityName: string;
+    entityDesignation: string;
+    tech_process?: any;
+    current?: any;
+    after?: any;
+    before?: any;
+}, {
+    id: number;
+    typeIzd: ProductionOperationType;
+    entityId: number;
+    operation_id: number;
+    tOperationId: number;
+    kolvo_create: number;
+    kolvo_shipments: number;
+    entityType: ActionEntityTypes.product | ActionEntityTypes.cbed | ActionEntityTypes.detal;
+    entityName: string;
+    entityDesignation: string;
+    tech_process?: any;
+    current?: any;
+    after?: any;
+    before?: any;
+}>;
+export type GetMarkForOperationType = z.infer<typeof getMarkForOperationTypeSchema>;

package/dist/marks/type/type.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarkForOperationTypeSchema = void 0;
+const zod_1 = require("zod");
+const action_1 = require("../../action");
+const utils_1 = require("../../utils");
+exports.getMarkForOperationTypeSchema = zod_1.z.object({
+    kolvo_create: zod_1.z.number().nonnegative(),
+    kolvo_shipments: zod_1.z.number().nonnegative(),
+    id: zod_1.z.number().int().nonnegative(),
+    current: zod_1.z.any(),
+    after: zod_1.z.any(),
+    before: zod_1.z.any(),
+    operation_id: zod_1.z.number().int().nonnegative(),
+    tOperationId: zod_1.z.number().int().nonnegative(),
+    entityName: zod_1.z.string(),
+    tech_process: zod_1.z.any(),
+    entityId: zod_1.z.number().int().nonnegative(),
+    typeIzd: zod_1.z.nativeEnum(utils_1.ProductionOperationType),
+    entityDesignation: zod_1.z.string(),
+    entityType: zod_1.z.union([
+        zod_1.z.literal(action_1.ActionEntityTypes.product),
+        zod_1.z.literal(action_1.ActionEntityTypes.cbed),
+        zod_1.z.literal(action_1.ActionEntityTypes.detal)
+    ])
+});