@pksep/zod-shared 0.0.490

package/dist/action/schemas/actions.schema.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionsSchema = void 0;
+const zod_1 = require("zod");
+exports.ActionsSchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    responsible_id: zod_1.z.number().nullish(),
+    action: zod_1.z.array(zod_1.z.custom()),
+    type_object: zod_1.z.string(),
+    ban: zod_1.z.boolean().optional().default(false),
+    equipment_id: zod_1.z.number().nullish(),
+    user_id: zod_1.z.number().nullish(),
+    movement_object_id: zod_1.z.number().nullish(),
+    deliveries_id: zod_1.z.number().nullish(),
+    provider_id: zod_1.z.number().nullish(),
+    shcomplit_id: zod_1.z.number().nullish(),
+    waybill_id: zod_1.z.number().nullish(),
+    document_id: zod_1.z.number().nullish(),
+    material_id: zod_1.z.number().nullish(),
+    instrument_id: zod_1.z.number().nullish(),
+    detal_id: zod_1.z.number().nullish(),
+    cbed_id: zod_1.z.number().nullish(),
+    rack_id: zod_1.z.number().nullish(),
+    product_id: zod_1.z.number().nullish(),
+    tech_process_id: zod_1.z.number().nullish(),
+    buyer_id: zod_1.z.number().nullish(),
+    inventary_id: zod_1.z.number().nullish(),
+    shipment_id: zod_1.z.number().nullish(),
+    metaloworking_id: zod_1.z.number().nullish(),
+    ass_id: zod_1.z.number().nullish(),
+    assembly_kit_id: zod_1.z.number().nullish(),
+    stock_order_id: zod_1.z.number().nullish(),
+    stock_order_item_id: zod_1.z.number().nullish(),
+    operation_id: zod_1.z.number().nullish(),
+    mark_id: zod_1.z.number().nullish(),
+    role_id: zod_1.z.number().nullish(),
+    parent_action_idL: zod_1.z.number().nullable().optional(),
+    production_task_id: zod_1.z.number().nullish()
+});

package/dist/action/types/types.d.ts

@@ -0,0 +1,4 @@
+import { ModelActions } from '../schemas/actions.schema';
+export type ActionWithParsedTextType = ModelActions & {
+    parsedActionsText: string[];
+};

package/dist/action/types/types.js

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

package/dist/assemble/dto/assemble-coming.dto.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { ParentTypeEnum } from '../../utils';
+import { EnumAssembleCominFilter } from '../enum/enum';
+export declare const GetAssembleComingDtoZod: z.ZodObject<{
+    page: z.ZodNumber;
+    searchString: z.ZodString;
+    filters: z.ZodDefault<z.ZodNativeEnum<typeof EnumAssembleCominFilter>>;
+    parentData: z.ZodDefault<z.ZodObject<{
+        parentType: z.ZodNullable<z.ZodNativeEnum<typeof ParentTypeEnum>>;
+        parentId: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        parentType: ParentTypeEnum | null;
+        parentId: number | null;
+    }, {
+        parentType: ParentTypeEnum | null;
+        parentId: number | null;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    searchString: string;
+    filters: EnumAssembleCominFilter;
+    parentData: {
+        parentType: ParentTypeEnum | null;
+        parentId: number | null;
+    };
+}, {
+    page: number;
+    searchString: string;
+    filters?: EnumAssembleCominFilter | undefined;
+    parentData?: {
+        parentType: ParentTypeEnum | null;
+        parentId: number | null;
+    } | undefined;
+}>;
+export type GetAssembleComingDtoZodType = z.infer<typeof GetAssembleComingDtoZod>;

package/dist/assemble/dto/assemble-coming.dto.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetAssembleComingDtoZod = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+const enum_1 = require("../enum/enum");
+exports.GetAssembleComingDtoZod = zod_1.z.object({
+    page: zod_1.z.number().int(),
+    searchString: zod_1.z.string(),
+    filters: zod_1.z
+        .nativeEnum(enum_1.EnumAssembleCominFilter)
+        .default(enum_1.EnumAssembleCominFilter.all),
+    parentData: zod_1.z
+        .object({
+        parentType: zod_1.z.nativeEnum(utils_1.ParentTypeEnum).nullable(),
+        parentId: zod_1.z.number().nullable()
+    })
+        .default({
+        parentType: null,
+        parentId: null
+    })
+});

package/dist/assemble/dto/assemble-db-request.dto.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { statusShipment } from '../../utils';
+export declare const IAssembleDbRequestDataZod: z.ZodObject<{
+    serchString: z.ZodOptional<z.ZodString>;
+    isIncludeBan: z.ZodOptional<z.ZodBoolean>;
+    status: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof statusShipment>, "many">>;
+    cbed: z.ZodObject<{
+        where: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        where: Record<string, any>;
+    }, {
+        where: Record<string, any>;
+    }>;
+    product: z.ZodObject<{
+        where: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        where: Record<string, any>;
+    }, {
+        where: Record<string, any>;
+    }>;
+    range: z.ZodOptional<z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        start: string;
+        end: string;
+    }, {
+        start: string;
+        end: string;
+    }>>;
+    isIncludeShipment: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    requiredShipments: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    product: {
+        where: Record<string, any>;
+    };
+    cbed: {
+        where: Record<string, any>;
+    };
+    status?: statusShipment[] | undefined;
+    isIncludeBan?: boolean | undefined;
+    serchString?: string | undefined;
+    range?: {
+        start: string;
+        end: string;
+    } | undefined;
+    isIncludeShipment?: boolean | null | undefined;
+    requiredShipments?: boolean | null | undefined;
+}, {
+    product: {
+        where: Record<string, any>;
+    };
+    cbed: {
+        where: Record<string, any>;
+    };
+    status?: statusShipment[] | undefined;
+    isIncludeBan?: boolean | undefined;
+    serchString?: string | undefined;
+    range?: {
+        start: string;
+        end: string;
+    } | undefined;
+    isIncludeShipment?: boolean | null | undefined;
+    requiredShipments?: boolean | null | undefined;
+}>;
+export type IAssembleDbRequestDataZodType = z.infer<typeof IAssembleDbRequestDataZod>;

package/dist/assemble/dto/assemble-db-request.dto.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IAssembleDbRequestDataZod = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+const WhereOptionsZod = zod_1.z.record(zod_1.z.any());
+exports.IAssembleDbRequestDataZod = zod_1.z.object({
+    serchString: zod_1.z.string().optional(),
+    isIncludeBan: zod_1.z.boolean().optional(),
+    status: zod_1.z.array(zod_1.z.nativeEnum(utils_1.statusShipment)).optional(),
+    cbed: zod_1.z.object({
+        where: WhereOptionsZod
+    }),
+    product: zod_1.z.object({
+        where: WhereOptionsZod
+    }),
+    range: zod_1.z
+        .object({
+        start: zod_1.z.string(),
+        end: zod_1.z.string()
+    })
+        .optional(),
+    isIncludeShipment: zod_1.z.boolean().nullable().optional(),
+    requiredShipments: zod_1.z.boolean().nullable().optional()
+});

package/dist/assemble/dto/assemble-deep-deficit.dto.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { IzdType } from '../../utils';
+export declare const GetDeepDeficitObjectDtoZod: z.ZodObject<{
+    id: z.ZodNumber;
+    entityId: z.ZodNumber;
+    assembleType: z.ZodNativeEnum<typeof IzdType>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    entityId: number;
+    assembleType: IzdType;
+}, {
+    id: number;
+    entityId: number;
+    assembleType: IzdType;
+}>;
+export type GetDeepDeficitObjectDtoZodType = z.infer<typeof GetDeepDeficitObjectDtoZod>;

package/dist/assemble/dto/assemble-deep-deficit.dto.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetDeepDeficitObjectDtoZod = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.GetDeepDeficitObjectDtoZod = zod_1.z.object({
+    id: zod_1.z.number().int(),
+    entityId: zod_1.z.number().int(),
+    assembleType: zod_1.z.nativeEnum(utils_1.IzdType)
+});

package/dist/assemble/dto/assembly-paginate.dto.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { ByParenType, ByShipmentsType, ByWorkersType, IzdType } from '../../utils';
+export declare const AssemblyPaginateDtoZod: z.ZodObject<{
+    type: z.ZodEnum<[IzdType.product, IzdType.cbed]>;
+    page: z.ZodOptional<z.ZodNumber>;
+    shipmentIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
+    searchString: z.ZodDefault<z.ZodString>;
+    byParent: z.ZodOptional<z.ZodNullable<z.ZodType<ByParenType, z.ZodTypeDef, ByParenType>>>;
+    byShipments: z.ZodOptional<z.ZodNullable<z.ZodType<ByShipmentsType, z.ZodTypeDef, ByShipmentsType>>>;
+    byWorkers: z.ZodOptional<z.ZodNullable<z.ZodType<ByWorkersType, z.ZodTypeDef, ByWorkersType>>>;
+    isShowDeactivate: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    type: IzdType.product | IzdType.cbed;
+    searchString: string;
+    isShowDeactivate: boolean;
+    page?: number | undefined;
+    shipmentIds?: number[] | null | undefined;
+    byParent?: ByParenType | null | undefined;
+    byShipments?: ByShipmentsType | null | undefined;
+    byWorkers?: ByWorkersType | null | undefined;
+}, {
+    type: IzdType.product | IzdType.cbed;
+    isShowDeactivate: boolean;
+    page?: number | undefined;
+    searchString?: string | undefined;
+    shipmentIds?: number[] | null | undefined;
+    byParent?: ByParenType | null | undefined;
+    byShipments?: ByShipmentsType | null | undefined;
+    byWorkers?: ByWorkersType | null | undefined;
+}>;
+export type AssemblyPaginateDtoZodType = z.infer<typeof AssemblyPaginateDtoZod>;

package/dist/assemble/dto/assembly-paginate.dto.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssemblyPaginateDtoZod = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+const IzdTypeEnum = zod_1.z.enum([utils_1.IzdType.product, utils_1.IzdType.cbed]);
+exports.AssemblyPaginateDtoZod = zod_1.z.object({
+    type: IzdTypeEnum,
+    page: zod_1.z.number().int().optional(),
+    shipmentIds: zod_1.z.array(zod_1.z.number()).nullable().optional(),
+    searchString: zod_1.z.string().default(''),
+    byParent: zod_1.z.custom().nullable().optional(),
+    byShipments: zod_1.z.custom().nullable().optional(),
+    byWorkers: zod_1.z.custom().nullable().optional(),
+    isShowDeactivate: zod_1.z.boolean()
+});

package/dist/assemble/dto/create-assemble-kit.dto.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const CreateAssembleKitDtoZod: z.ZodObject<{
+    kolvoCollected: z.ZodNumber;
+    assembleId: z.ZodNumber;
+    shipmentsIds: z.ZodArray<z.ZodNumber, "many">;
+    listCbed: z.ZodAny;
+    listDetal: z.ZodAny;
+    actionSendlerId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    assembleId: number;
+    kolvoCollected: number;
+    shipmentsIds: number[];
+    actionSendlerId: number;
+    listDetal?: any;
+    listCbed?: any;
+}, {
+    assembleId: number;
+    kolvoCollected: number;
+    shipmentsIds: number[];
+    actionSendlerId: number;
+    listDetal?: any;
+    listCbed?: any;
+}>;
+export type CreateAssembleKitDtoType = z.infer<typeof CreateAssembleKitDtoZod>;

package/dist/assemble/dto/create-assemble-kit.dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAssembleKitDtoZod = void 0;
+const zod_1 = require("zod");
+exports.CreateAssembleKitDtoZod = zod_1.z.object({
+    kolvoCollected: zod_1.z.number().int(),
+    assembleId: zod_1.z.number().int(),
+    shipmentsIds: zod_1.z.array(zod_1.z.number()),
+    listCbed: zod_1.z.any(),
+    listDetal: zod_1.z.any(),
+    actionSendlerId: zod_1.z.number().int()
+});

package/dist/assemble/dto/create-assemble.dto.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const CreateAssembleDtoZod: z.ZodObject<{
+    numberOrder: z.ZodString;
+    myKolvo: z.ZodNumber;
+    description: z.ZodString;
+    cbedId: z.ZodNumber;
+    type: z.ZodString;
+    actionSendlerId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    description: string;
+    cbedId: number;
+    myKolvo: number;
+    actionSendlerId: number;
+    numberOrder: string;
+}, {
+    type: string;
+    description: string;
+    cbedId: number;
+    myKolvo: number;
+    actionSendlerId: number;
+    numberOrder: string;
+}>;
+export type CreateAssembleDtoZodType = z.infer<typeof CreateAssembleDtoZod>;

package/dist/assemble/dto/create-assemble.dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAssembleDtoZod = void 0;
+const zod_1 = require("zod");
+exports.CreateAssembleDtoZod = zod_1.z.object({
+    numberOrder: zod_1.z.string(),
+    myKolvo: zod_1.z.number().int(),
+    description: zod_1.z.string(),
+    cbedId: zod_1.z.number().int(),
+    type: zod_1.z.string(),
+    actionSendlerId: zod_1.z.number().int()
+});

package/dist/assemble/dto/delete-actual-shipment.dto.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const SetActualShipmentAssembleDtoZod: z.ZodObject<{
+    cbedIds: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    productIds: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    transaction: z.ZodDefault<z.ZodOptional<z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    transaction?: any;
+    cbedIds?: number[] | undefined;
+    productIds?: number[] | undefined;
+}, {
+    transaction?: any;
+    cbedIds?: number[] | undefined;
+    productIds?: number[] | undefined;
+}>;
+export type SetActualShipmentAssembleDtoZodType = z.infer<typeof SetActualShipmentAssembleDtoZod>;

package/dist/assemble/dto/delete-actual-shipment.dto.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetActualShipmentAssembleDtoZod = void 0;
+const zod_1 = require("zod");
+exports.SetActualShipmentAssembleDtoZod = zod_1.z.object({
+    cbedIds: zod_1.z.array(zod_1.z.number()).optional(),
+    productIds: zod_1.z.array(zod_1.z.number()).optional(),
+    transaction: zod_1.z.any().optional().default({})
+});

package/dist/assemble/dto/delete-assemble.dto.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const DeleteAssembleDtoZod: z.ZodObject<{
+    id: z.ZodNumber;
+    description: z.ZodString;
+    userId: z.ZodOptional<z.ZodNumber>;
+    transactionArgument: z.ZodOptional<z.ZodAny>;
+    relativeActionId: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    id: number;
+    userId?: number | undefined;
+    transactionArgument?: any;
+    relativeActionId?: number | null | undefined;
+}, {
+    description: string;
+    id: number;
+    userId?: number | undefined;
+    transactionArgument?: any;
+    relativeActionId?: number | null | undefined;
+}>;
+export type DeleteAssembleDtoZodType = z.infer<typeof DeleteAssembleDtoZod>;

package/dist/assemble/dto/delete-assemble.dto.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteAssembleDtoZod = void 0;
+const zod_1 = require("zod");
+exports.DeleteAssembleDtoZod = zod_1.z.object({
+    id: zod_1.z.number().describe('Идентификатор сущности'),
+    description: zod_1.z.string().describe('Описание'),
+    userId: zod_1.z.number().optional().describe('Идентификатор активатора события'),
+    transactionArgument: zod_1.z.any().optional().describe('Транзакция'),
+    relativeActionId: zod_1.z.number().optional().nullable()
+});

package/dist/assemble/dto/delete-shipment.dto.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const DeleteShipmentAssembleDtoZod: z.ZodObject<{
+    shipmentId: z.ZodNumber;
+    transaction: z.ZodDefault<z.ZodOptional<z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    shipmentId: number;
+    transaction?: any;
+}, {
+    shipmentId: number;
+    transaction?: any;
+}>;
+export type DeleteShipmentAssembleDtoZodType = z.infer<typeof DeleteShipmentAssembleDtoZod>;

package/dist/assemble/dto/delete-shipment.dto.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteShipmentAssembleDtoZod = void 0;
+const zod_1 = require("zod");
+exports.DeleteShipmentAssembleDtoZod = zod_1.z.object({
+    shipmentId: zod_1.z.number().int(),
+    transaction: zod_1.z.any().optional().default({})
+});

package/dist/assemble/dto/get-assemble-by-id.dto.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const GetAssembleByIdDtoZod: z.ZodObject<{
+    id: z.ZodNumber;
+    sort: z.ZodDefault<z.ZodBoolean>;
+    isIncludeBan: z.ZodNullable<z.ZodDefault<z.ZodBoolean>>;
+    transaction: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    sort: boolean;
+    id: number;
+    isIncludeBan: boolean | null;
+    transaction?: any;
+}, {
+    id: number;
+    sort?: boolean | undefined;
+    isIncludeBan?: boolean | null | undefined;
+    transaction?: any;
+}>;
+export type GetAssembleByIdDtoZodType = z.infer<typeof GetAssembleByIdDtoZod>;

package/dist/assemble/dto/get-assemble-by-id.dto.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetAssembleByIdDtoZod = void 0;
+const zod_1 = require("zod");
+exports.GetAssembleByIdDtoZod = zod_1.z.object({
+    id: zod_1.z.number().int(),
+    sort: zod_1.z.boolean().default(true),
+    isIncludeBan: zod_1.z.boolean().default(false).nullable(),
+    transaction: zod_1.z.any().optional()
+});

package/dist/assemble/dto/get-assemble-by-izd.dto.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const GetAssembleByIzdIdDtoZod: z.ZodObject<{
+    entityId: z.ZodNumber;
+    entityType: z.ZodDefault<z.ZodString>;
+    isIncludeBan: z.ZodDefault<z.ZodBoolean>;
+    transaction: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    isIncludeBan: boolean;
+    entityId: number;
+    entityType: string;
+    transaction?: any;
+}, {
+    entityId: number;
+    isIncludeBan?: boolean | undefined;
+    transaction?: any;
+    entityType?: string | undefined;
+}>;
+export type GetAssembleByIzdIdDtoZodType = z.infer<typeof GetAssembleByIzdIdDtoZod>;

package/dist/assemble/dto/get-assemble-by-izd.dto.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetAssembleByIzdIdDtoZod = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.GetAssembleByIzdIdDtoZod = zod_1.z.object({
+    entityId: zod_1.z.number().int(),
+    entityType: zod_1.z.string().default(`${utils_1.IzdType.product}`),
+    isIncludeBan: zod_1.z.boolean().default(false),
+    transaction: zod_1.z.any().optional()
+});