@pksep/zod-shared 0.0.490

package/dist/production-tasks/schemas/production-operation-pos.schema.d.ts

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+import { ModelAssemble } from '../../assemble';
+import { ModelMetaloworking } from '../../metaloworking';
+import { IEmployeePosition, IEquipmentPosition } from '../interfaces/production-tasks';
+import { ModelProductionTask } from './production-task.schema';
+import { ModelUser } from '../../user';
+import { StockOrderType } from '../../utils';
+export declare const UserProdactionTaskFilterSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    operationId: z.ZodNumber;
+    idx: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    userId: number;
+    operationId: number;
+    idx: number;
+}, {
+    userId: number;
+    operationId: number;
+    idx: number;
+}>;
+export declare const OperationPositionSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    employeePositions: z.ZodArray<z.ZodType<IEmployeePosition, z.ZodTypeDef, IEmployeePosition>, "many">;
+    equipmentPositions: z.ZodArray<z.ZodType<IEquipmentPosition, z.ZodTypeDef, IEquipmentPosition>, "many">;
+    tOperationId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    tOperationId: number;
+    employeePositions: IEmployeePosition[];
+    equipmentPositions: IEquipmentPosition[];
+}, {
+    id: number;
+    tOperationId: number;
+    employeePositions: IEmployeePosition[];
+    equipmentPositions: IEquipmentPosition[];
+}>;
+export declare const ProductionOperationPosSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    type: z.ZodNativeEnum<typeof StockOrderType>;
+    production_task_id: z.ZodNumber;
+    ass_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    metall_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    idx: z.ZodNumber;
+    quantity_max: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    start_time: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    user_filter: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        userId: z.ZodNumber;
+        operationId: z.ZodNumber;
+        idx: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        userId: number;
+        operationId: number;
+        idx: number;
+    }, {
+        userId: number;
+        operationId: number;
+        idx: number;
+    }>, "many">>;
+    responsible_user_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    quantity: z.ZodNumber;
+    global_index: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    create_time_minutes: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    ban: z.ZodDefault<z.ZodBoolean>;
+    operation_positions: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        employeePositions: z.ZodArray<z.ZodType<IEmployeePosition, z.ZodTypeDef, IEmployeePosition>, "many">;
+        equipmentPositions: z.ZodArray<z.ZodType<IEquipmentPosition, z.ZodTypeDef, IEquipmentPosition>, "many">;
+        tOperationId: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        tOperationId: number;
+        employeePositions: IEmployeePosition[];
+        equipmentPositions: IEquipmentPosition[];
+    }, {
+        id: number;
+        tOperationId: number;
+        employeePositions: IEmployeePosition[];
+        equipmentPositions: IEquipmentPosition[];
+    }>, "many">;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    type: StockOrderType;
+    ban: boolean;
+    quantity: number;
+    production_task_id: number;
+    idx: number;
+    user_filter: {
+        userId: number;
+        operationId: number;
+        idx: number;
+    }[];
+    operation_positions: {
+        id: number;
+        tOperationId: number;
+        employeePositions: IEmployeePosition[];
+        equipmentPositions: IEquipmentPosition[];
+    }[];
+    id?: number | null | undefined;
+    responsible_user_id?: number | null | undefined;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+    ass_id?: number | null | undefined;
+    metall_id?: number | null | undefined;
+    quantity_max?: number | null | undefined;
+    start_time?: Date | null | undefined;
+    global_index?: number | null | undefined;
+    create_time_minutes?: number | null | undefined;
+}, {
+    type: StockOrderType;
+    quantity: number;
+    production_task_id: number;
+    idx: number;
+    operation_positions: {
+        id: number;
+        tOperationId: number;
+        employeePositions: IEmployeePosition[];
+        equipmentPositions: IEquipmentPosition[];
+    }[];
+    ban?: boolean | undefined;
+    id?: number | null | undefined;
+    responsible_user_id?: number | null | undefined;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+    ass_id?: number | null | undefined;
+    metall_id?: number | null | undefined;
+    quantity_max?: number | null | undefined;
+    start_time?: Date | null | undefined;
+    user_filter?: {
+        userId: number;
+        operationId: number;
+        idx: number;
+    }[] | undefined;
+    global_index?: number | null | undefined;
+    create_time_minutes?: number | null | undefined;
+}>;
+export type ModelProductionOperationPos = z.infer<typeof ProductionOperationPosSchema> & {
+    production_task?: ModelProductionTask;
+    assemble?: ModelAssemble;
+    metaloworking?: ModelMetaloworking;
+    responsible_user?: ModelUser;
+};

package/dist/production-tasks/schemas/production-operation-pos.schema.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductionOperationPosSchema = exports.OperationPositionSchema = exports.UserProdactionTaskFilterSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.UserProdactionTaskFilterSchema = zod_1.z.object({
+    userId: zod_1.z.number(),
+    operationId: zod_1.z.number(),
+    idx: zod_1.z.number()
+});
+exports.OperationPositionSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    employeePositions: zod_1.z.array(zod_1.z.custom()),
+    equipmentPositions: zod_1.z.array(zod_1.z.custom()),
+    tOperationId: zod_1.z.number()
+});
+exports.ProductionOperationPosSchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    type: zod_1.z.nativeEnum(utils_1.StockOrderType),
+    production_task_id: zod_1.z.number(),
+    ass_id: zod_1.z.number().nullish(),
+    metall_id: zod_1.z.number().nullish(),
+    idx: zod_1.z.number(),
+    quantity_max: zod_1.z.number().nullish(),
+    start_time: zod_1.z.date().nullish(),
+    user_filter: zod_1.z.array(exports.UserProdactionTaskFilterSchema).default([]),
+    responsible_user_id: zod_1.z.number().nullish(),
+    quantity: zod_1.z.number(),
+    global_index: zod_1.z.number().nullish(),
+    create_time_minutes: zod_1.z.number().nullish(),
+    ban: zod_1.z.boolean().default(false),
+    operation_positions: zod_1.z.array(exports.OperationPositionSchema),
+    createdAt: zod_1.z.date().optional(),
+    updatedAt: zod_1.z.date().optional()
+});

package/dist/production-tasks/schemas/production-taks-assembly.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+declare const ProductionTaskAssemblySchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    production_task_id: z.ZodNumber;
+    assembly_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    production_task_id: number;
+    assembly_id: number;
+    id?: number | null | undefined;
+}, {
+    production_task_id: number;
+    assembly_id: number;
+    id?: number | null | undefined;
+}>;
+export type ModelProductionTaskAssembly = z.infer<typeof ProductionTaskAssemblySchema>;
+export {};

package/dist/production-tasks/schemas/production-taks-assembly.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const ProductionTaskAssemblySchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    production_task_id: zod_1.z.number().int().positive(),
+    assembly_id: zod_1.z.number().int().positive()
+});

package/dist/production-tasks/schemas/production-taks-metalloworkig.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+declare const ProductionTaskMetalloworkingSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    production_task_id: z.ZodNumber;
+    metalloworking_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    production_task_id: number;
+    metalloworking_id: number;
+    id?: number | null | undefined;
+}, {
+    production_task_id: number;
+    metalloworking_id: number;
+    id?: number | null | undefined;
+}>;
+export type ModelProductionTaskMetalloworking = z.infer<typeof ProductionTaskMetalloworkingSchema>;
+export {};

package/dist/production-tasks/schemas/production-taks-metalloworkig.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const ProductionTaskMetalloworkingSchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    production_task_id: zod_1.z.number().int().positive(),
+    metalloworking_id: zod_1.z.number().int().positive()
+});

package/dist/production-tasks/schemas/production-taks-start-time.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+declare const StartTimeSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    user_id: z.ZodNumber;
+    time: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    user_id: number;
+    time: Date;
+    id?: number | null | undefined;
+}, {
+    user_id: number;
+    time: Date;
+    id?: number | null | undefined;
+}>;
+export type ModelStartTime = z.infer<typeof StartTimeSchema>;
+export {};

package/dist/production-tasks/schemas/production-taks-start-time.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const StartTimeSchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    user_id: zod_1.z.number().int(),
+    time: zod_1.z.date()
+});

package/dist/production-tasks/schemas/production-task.schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { StockOrderType } from '../../utils';
+import { StatusProductionTaskEnum } from '../enums/production-tasks';
+import { IDescriptionFilters } from '../interfaces/production-tasks';
+import { ModelAssemble } from '../../assemble';
+import { ModelMetaloworking } from '../../metaloworking';
+import { ModelMarks } from '../../marks';
+import { ModelProductionOperationPos } from './production-operation-pos.schema';
+export declare const ProductionTaskSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    due_data: z.ZodDate;
+    working_type: z.ZodNativeEnum<typeof StockOrderType>;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodNativeEnum<typeof StatusProductionTaskEnum>>;
+    details_filters: z.ZodType<IDescriptionFilters, z.ZodTypeDef, IDescriptionFilters>;
+}, "strip", z.ZodTypeAny, {
+    status: StatusProductionTaskEnum;
+    due_data: Date;
+    working_type: StockOrderType;
+    details_filters: IDescriptionFilters;
+    description?: string | undefined;
+    id?: number | null | undefined;
+}, {
+    due_data: Date;
+    working_type: StockOrderType;
+    details_filters: IDescriptionFilters;
+    status?: StatusProductionTaskEnum | undefined;
+    description?: string | undefined;
+    id?: number | null | undefined;
+}>;
+export type ModelProductionTask = z.infer<typeof ProductionTaskSchema> & {
+    ass?: ModelAssemble[];
+    metall?: ModelMetaloworking[];
+    marks?: ModelMarks[];
+    production_operation_pos?: ModelProductionOperationPos[];
+};

package/dist/production-tasks/schemas/production-task.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductionTaskSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+const production_tasks_1 = require("../enums/production-tasks");
+exports.ProductionTaskSchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    due_data: zod_1.z.date(),
+    working_type: zod_1.z.nativeEnum(utils_1.StockOrderType),
+    description: zod_1.z.string().optional(),
+    status: zod_1.z
+        .nativeEnum(production_tasks_1.StatusProductionTaskEnum)
+        .default(production_tasks_1.StatusProductionTaskEnum.active),
+    details_filters: zod_1.z.custom()
+});

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

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { EntityCommonSpecificationArray } from '../../utils';
+export declare const CreateProviderDtoZod: z.ZodObject<{
+    id: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    name: z.ZodString;
+    inn: z.ZodString;
+    cpp: z.ZodString;
+    rekvisit: z.ZodString;
+    contacts: z.ZodString;
+    description: z.ZodString;
+    docs: z.ZodOptional<z.ZodString>;
+    materialList: z.ZodEffects<z.ZodDefault<z.ZodType<EntityCommonSpecificationArray, z.ZodTypeDef, EntityCommonSpecificationArray>>, EntityCommonSpecificationArray, unknown>;
+    toolListId: z.ZodOptional<z.ZodString>;
+    equipmentListId: z.ZodOptional<z.ZodString>;
+    attention: z.ZodEffects<z.ZodString, boolean, string>;
+    fileBase: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    name: string;
+    contacts: string;
+    inn: string;
+    cpp: string;
+    rekvisit: string;
+    attention: boolean;
+    fileBase: string;
+    materialList: EntityCommonSpecificationArray;
+    id?: string | null | undefined;
+    docs?: string | undefined;
+    toolListId?: string | undefined;
+    equipmentListId?: string | undefined;
+}, {
+    description: string;
+    name: string;
+    contacts: string;
+    inn: string;
+    cpp: string;
+    rekvisit: string;
+    attention: string;
+    fileBase: string;
+    id?: string | null | undefined;
+    docs?: string | undefined;
+    materialList?: unknown;
+    toolListId?: string | undefined;
+    equipmentListId?: string | undefined;
+}>;
+export type CreateProviderDtoType = z.infer<typeof CreateProviderDtoZod>;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateProviderDtoZod = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.CreateProviderDtoZod = zod_1.z.object({
+    id: zod_1.z.string().optional().nullable(),
+    name: zod_1.z.string(),
+    inn: zod_1.z.string(),
+    cpp: zod_1.z.string(),
+    rekvisit: zod_1.z.string(),
+    contacts: zod_1.z.string(),
+    description: zod_1.z.string(),
+    docs: zod_1.z.string().optional(),
+    materialList: zod_1.z.preprocess(val => (0, utils_1.parseParamsOrBody)(val, []), zod_1.z.custom().default([])),
+    toolListId: zod_1.z.string().optional(),
+    equipmentListId: zod_1.z.string().optional(),
+    attention: zod_1.z.string().transform(val => val === 'true'),
+    fileBase: zod_1.z.string()
+});

package/dist/provider/dto/provider-pagination.dto.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const ProviderPaginationDtoZod: z.ZodObject<{
+    page: z.ZodDefault<z.ZodNumber>;
+    searchString: z.ZodDefault<z.ZodString>;
+    isSortedByAttention: z.ZodDefault<z.ZodBoolean>;
+    isSortedByDate: z.ZodDefault<z.ZodBoolean>;
+    materialProvidersIds: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    searchString: string;
+    isSortedByAttention: boolean;
+    isSortedByDate: boolean;
+    materialProvidersIds: string;
+}, {
+    page?: number | undefined;
+    searchString?: string | undefined;
+    isSortedByAttention?: boolean | undefined;
+    isSortedByDate?: boolean | undefined;
+    materialProvidersIds?: string | undefined;
+}>;
+export type ProviderPaginationDtoType = z.infer<typeof ProviderPaginationDtoZod>;

package/dist/provider/dto/provider-pagination.dto.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderPaginationDtoZod = void 0;
+const zod_1 = require("zod");
+exports.ProviderPaginationDtoZod = zod_1.z.object({
+    page: zod_1.z.number().default(1),
+    searchString: zod_1.z.string().default(''),
+    isSortedByAttention: zod_1.z.boolean().default(false),
+    isSortedByDate: zod_1.z.boolean().default(false),
+    materialProvidersIds: zod_1.z.string().default('')
+});

package/dist/provider/index.d.ts

@@ -0,0 +1,6 @@
+export * from './schemas/provider.schema';
+export * from './schemas/providers-equipment.schema';
+export * from './schemas/providers-inventary.schema';
+export * from './interfaces/interface';
+export * from './dto/create-provider.dto';
+export * from './dto/provider-pagination.dto';

package/dist/provider/index.js

@@ -0,0 +1,22 @@
+"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("./schemas/provider.schema"), exports);
+__exportStar(require("./schemas/providers-equipment.schema"), exports);
+__exportStar(require("./schemas/providers-inventary.schema"), exports);
+__exportStar(require("./interfaces/interface"), exports);
+__exportStar(require("./dto/create-provider.dto"), exports);
+__exportStar(require("./dto/provider-pagination.dto"), exports);

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

@@ -0,0 +1,3 @@
+export interface IProvidersCreationAttrs {
+    name: string;
+}

package/dist/provider/interfaces/interface.js

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

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const ProvidersSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    name: z.ZodString;
+    inn: z.ZodOptional<z.ZodString>;
+    cpp: z.ZodOptional<z.ZodString>;
+    rekvisit: z.ZodOptional<z.ZodString>;
+    contacts: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ban: z.ZodDefault<z.ZodBoolean>;
+    attention: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    ban: boolean;
+    name: string;
+    attention: boolean;
+    description?: string | undefined;
+    id?: number | null | undefined;
+    contacts?: string | undefined;
+    inn?: string | undefined;
+    cpp?: string | undefined;
+    rekvisit?: string | undefined;
+}, {
+    name: string;
+    ban?: boolean | undefined;
+    description?: string | undefined;
+    id?: number | null | undefined;
+    contacts?: string | undefined;
+    inn?: string | undefined;
+    cpp?: string | undefined;
+    rekvisit?: string | undefined;
+    attention?: boolean | undefined;
+}>;
+export type ModelProviders = z.infer<typeof ProvidersSchema>;

package/dist/provider/schemas/provider.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProvidersSchema = void 0;
+const zod_1 = require("zod");
+exports.ProvidersSchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    name: zod_1.z.string().min(1, 'Name is required'),
+    inn: zod_1.z.string().optional(),
+    cpp: zod_1.z.string().optional(),
+    rekvisit: zod_1.z.string().optional(),
+    contacts: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    ban: zod_1.z.boolean().default(false),
+    attention: zod_1.z.boolean().default(false)
+});

package/dist/provider/schemas/providers-equipment.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+declare const ProvidersEquipmentSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    providerId: z.ZodNumber;
+    equipmentsId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    providerId: number;
+    equipmentsId: number;
+    id?: number | null | undefined;
+}, {
+    providerId: number;
+    equipmentsId: number;
+    id?: number | null | undefined;
+}>;
+export type ModelProvidersEquipment = z.infer<typeof ProvidersEquipmentSchema>;
+export {};

package/dist/provider/schemas/providers-equipment.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const ProvidersEquipmentSchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    providerId: zod_1.z.number().int().positive(),
+    equipmentsId: zod_1.z.number().int().positive()
+});

package/dist/provider/schemas/providers-inventary.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+declare const ProvidersInventarySchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    provider_id: z.ZodNumber;
+    inventary_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    provider_id: number;
+    inventary_id: number;
+    id?: number | null | undefined;
+}, {
+    provider_id: number;
+    inventary_id: number;
+    id?: number | null | undefined;
+}>;
+export type ModelProvidersInventary = z.infer<typeof ProvidersInventarySchema>;
+export {};

package/dist/provider/schemas/providers-inventary.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const ProvidersInventarySchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    provider_id: zod_1.z.number().int().positive(),
+    inventary_id: zod_1.z.number().int().positive()
+});