@pksep/zod-shared 0.0.490

package/dist/detal/schemas/detal.schema.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetalSchema = void 0;
+const zod_1 = require("zod");
+const document_1 = require("../../document");
+const cbed_1 = require("../../cbed");
+const shipments_1 = require("../../shipments");
+const metaloworking_1 = require("../../metaloworking");
+const utils_1 = require("../../utils");
+const material_1 = require("../../material");
+const product_1 = require("../../product");
+const stock_order_1 = require("../../stock-order");
+exports.DetalSchema = zod_1.z.object({
+    id: zod_1.z.number().int().positive(),
+    name: zod_1.z.string(),
+    ban: zod_1.z.boolean().default(false),
+    quantity: zod_1.z.number().int().default(0),
+    min_remaining: zod_1.z.number().int().default(0),
+    remainder_after_coming: zod_1.z.number().int().default(0),
+    deficit: zod_1.z.number().int().default(0),
+    shipments_kolvo: zod_1.z.number().int().default(0),
+    production_ordered: zod_1.z.number().int().default(0),
+    deficit_by_sclad: zod_1.z.number().int().default(0),
+    designation: zod_1.z.string().nullish(),
+    description: zod_1.z.string().nullish(),
+    ava_path: zod_1.z.string().nullish(),
+    production_time_metalloworking: zod_1.z
+        .custom()
+        .default(utils_1.defaultProducitonTime)
+        .nullish(),
+    attention: zod_1.z.boolean().default(false),
+    parametrs: zod_1.z.custom().nullable(),
+    characteristic: zod_1.z.custom().nullable(),
+    workpiece_characterization: zod_1.z
+        .custom()
+        .nullable(),
+    materialList: zod_1.z.custom().default([]),
+    in_kit: zod_1.z.number().int().default(0),
+    documents: zod_1.z.array(document_1.DocumentsSchema).optional(),
+    materials: zod_1.z.array(material_1.MaterialSchema).optional(),
+    mat_zag: zod_1.z.number().int().nullish(),
+    mat_za_obj: zod_1.z.custom().optional(),
+    mat_zag_zam: zod_1.z.number().int().nullish(),
+    techProcesses: zod_1.z.custom().optional(),
+    responsibleId: zod_1.z.number().int(),
+    cbed: zod_1.z.array(cbed_1.CbedSchema).optional(),
+    products: zod_1.z.array(product_1.ProductSchema).optional(),
+    metaloworking: zod_1.z.array(metaloworking_1.MetaloworkingSchema).optional(),
+    sebestoim: zod_1.z.custom().optional(),
+    stock_orders_items: zod_1.z.array(stock_order_1.StockOrderItemSchema).optional(),
+    shipments: zod_1.z.array(shipments_1.ShipmentsSchema).optional(),
+    discontinued: zod_1.z.boolean().optional()
+});

package/dist/detal/types/detal.d.ts

@@ -0,0 +1,15 @@
+export type detalCharacteristicItem = {
+    name: string;
+    ez: string;
+    znach: string | number;
+};
+export type detalCharacteristicField = detalCharacteristicItem[];
+export type detalParametrsType = {
+    ez: string;
+    znach: string | number;
+};
+export type detalParametrsField = {
+    preTime: detalParametrsType;
+    helperTime: detalParametrsType;
+    mainTime: detalParametrsType;
+};

package/dist/detal/types/detal.js

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

package/dist/document/dto/attach-document-to-entity.dto.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ModuleIncludeForDocumentEnum } from '../../utils';
+export declare const AttachDocumentToEntityDtoZod: z.ZodObject<{
+    idEntity: z.ZodNumber;
+    idDocument: z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>;
+    typeEntity: z.ZodNativeEnum<typeof ModuleIncludeForDocumentEnum>;
+}, "strip", z.ZodTypeAny, {
+    idEntity: number;
+    idDocument: number | number[];
+    typeEntity: ModuleIncludeForDocumentEnum;
+}, {
+    idEntity: number;
+    idDocument: number | number[];
+    typeEntity: ModuleIncludeForDocumentEnum;
+}>;
+export type AttachDocumentToEntityDtoType = z.infer<typeof AttachDocumentToEntityDtoZod>;

package/dist/document/dto/attach-document-to-entity.dto.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachDocumentToEntityDtoZod = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.AttachDocumentToEntityDtoZod = zod_1.z.object({
+    idEntity: zod_1.z.number().int(),
+    idDocument: zod_1.z.union([zod_1.z.number().int(), zod_1.z.array(zod_1.z.number().int())]),
+    typeEntity: zod_1.z.nativeEnum(utils_1.ModuleIncludeForDocumentEnum)
+});

package/dist/document/dto/change-type.dto.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const ChangeTypeDtoZod: z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    id: number;
+}, {
+    type: string;
+    id: number;
+}>;
+export type ChangeTypeDtoType = z.infer<typeof ChangeTypeDtoZod>;

package/dist/document/dto/change-type.dto.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeTypeDtoZod = void 0;
+const zod_1 = require("zod");
+exports.ChangeTypeDtoZod = zod_1.z.object({
+    id: zod_1.z.number(),
+    type: zod_1.z.string()
+});

package/dist/document/dto/check-name-exist.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const CheckNameExistingDtoZod: z.ZodObject<{
+    name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name?: string | undefined;
+}>;
+export type CheckNameExistingDtoType = z.infer<typeof CheckNameExistingDtoZod>;

package/dist/document/dto/check-name-exist.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckNameExistingDtoZod = void 0;
+const zod_1 = require("zod");
+exports.CheckNameExistingDtoZod = zod_1.z.object({
+    name: zod_1.z.string().optional().default('')
+});

package/dist/document/dto/create-arr-documents.dto.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const CreateArrDocumentsDtoZod: z.ZodObject<{
+    docs: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    docs: string;
+}, {
+    docs: string;
+}>;
+export type CreateArrDocumentsDtoType = z.infer<typeof CreateArrDocumentsDtoZod>;

package/dist/document/dto/create-arr-documents.dto.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateArrDocumentsDtoZod = void 0;
+const zod_1 = require("zod");
+exports.CreateArrDocumentsDtoZod = zod_1.z.object({
+    docs: zod_1.z.string()
+});

package/dist/document/dto/create-documents.dto.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const CreateDocumentsDtoZod: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodNumber;
+    type: z.ZodString;
+    ava: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: string;
+    description: string;
+    name: string;
+    version: number;
+    ava: boolean;
+}, {
+    path: string;
+    type: string;
+    description: string;
+    name: string;
+    version: number;
+    ava?: boolean | undefined;
+}>;
+export type CreateDocumentsDtoType = z.infer<typeof CreateDocumentsDtoZod>;

package/dist/document/dto/create-documents.dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDocumentsDtoZod = void 0;
+const zod_1 = require("zod");
+exports.CreateDocumentsDtoZod = zod_1.z.object({
+    name: zod_1.z.string(),
+    path: zod_1.z.string(),
+    description: zod_1.z.string(),
+    version: zod_1.z.number(),
+    type: zod_1.z.string(),
+    ava: zod_1.z.boolean().optional().default(false)
+});

package/dist/document/dto/query-pagination.dto.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { filterOptions } from '../../utils';
+export declare const QueryPaginationDtoZod: z.ZodObject<{
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    filterOptions: z.ZodDefault<z.ZodOptional<z.ZodType<filterOptions, z.ZodTypeDef, filterOptions>>>;
+    searchString: z.ZodDefault<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    searchString: string | null;
+    filterOptions: filterOptions;
+}, {
+    page?: number | undefined;
+    searchString?: string | null | undefined;
+    filterOptions?: filterOptions | undefined;
+}>;
+export type QueryPaginationDtoType = z.infer<typeof QueryPaginationDtoZod>;

package/dist/document/dto/query-pagination.dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryPaginationDtoZod = void 0;
+const zod_1 = require("zod");
+exports.QueryPaginationDtoZod = zod_1.z.object({
+    page: zod_1.z.number().optional().default(1),
+    filterOptions: zod_1.z.custom().optional().default({
+        typeFile: null,
+        category: null
+    }),
+    searchString: zod_1.z.string().optional().nullable().default('')
+});

package/dist/document/dto/unpin-document.dto.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ModuleIncludeForDocumentEnum } from '../../utils';
+export declare const UnpinDocumentDtoSchema: z.ZodObject<{
+    idEntity: z.ZodNumber;
+    idDocument: z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>;
+    typeEntity: z.ZodNativeEnum<typeof ModuleIncludeForDocumentEnum>;
+}, "strip", z.ZodTypeAny, {
+    idEntity: number;
+    idDocument: number | number[];
+    typeEntity: ModuleIncludeForDocumentEnum;
+}, {
+    idEntity: number;
+    idDocument: number | number[];
+    typeEntity: ModuleIncludeForDocumentEnum;
+}>;
+export type UnpinDocumentDtoType = z.infer<typeof UnpinDocumentDtoSchema>;

package/dist/document/dto/unpin-document.dto.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnpinDocumentDtoSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.UnpinDocumentDtoSchema = zod_1.z.object({
+    idEntity: zod_1.z.number().int(),
+    idDocument: zod_1.z.union([zod_1.z.number().int(), zod_1.z.array(zod_1.z.number().int())]),
+    typeEntity: zod_1.z.nativeEnum(utils_1.ModuleIncludeForDocumentEnum)
+});

package/dist/document/dto/update-document.dto.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const UpdateDocumentDtoZod: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, number | null | undefined, unknown>;
+    type: z.ZodString;
+    responsibleUserId: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    id: z.ZodNumber;
+    description: z.ZodString;
+    ava: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    description: string;
+    id: number;
+    name: string;
+    ava: boolean;
+    responsibleUserId: number | null;
+    version?: number | null | undefined;
+}, {
+    type: string;
+    description: string;
+    id: number;
+    name: string;
+    version?: unknown;
+    ava?: boolean | undefined;
+    responsibleUserId?: number | null | undefined;
+}>;
+export type UpdateDocumentDtoType = z.infer<typeof UpdateDocumentDtoZod>;

package/dist/document/dto/update-document.dto.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateDocumentDtoZod = void 0;
+const zod_1 = require("zod");
+exports.UpdateDocumentDtoZod = zod_1.z.object({
+    name: zod_1.z.string(),
+    version: zod_1.z.preprocess(val => typeof val === 'string' && parseInt(val, 10) ? parseInt(val, 10) : val, zod_1.z.number().nullable().optional()),
+    type: zod_1.z.string(),
+    responsibleUserId: zod_1.z.number().nullable().default(null),
+    id: zod_1.z.number(),
+    description: zod_1.z.string(),
+    ava: zod_1.z.boolean().optional().default(false)
+});

package/dist/document/index.d.ts

@@ -0,0 +1,10 @@
+export * from './schemas/documentsSchema';
+export * from './interfaces/interface';
+export * from './dto/unpin-document.dto';
+export * from './dto/change-type.dto';
+export * from './dto/check-name-exist';
+export * from './dto/create-arr-documents.dto';
+export * from './dto/create-documents.dto';
+export * from './dto/query-pagination.dto';
+export * from './dto/update-document.dto';
+export * from './dto/attach-document-to-entity.dto';

package/dist/document/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("./schemas/documentsSchema"), exports);
+__exportStar(require("./interfaces/interface"), exports);
+__exportStar(require("./dto/unpin-document.dto"), exports);
+__exportStar(require("./dto/change-type.dto"), exports);
+__exportStar(require("./dto/check-name-exist"), exports);
+__exportStar(require("./dto/create-arr-documents.dto"), exports);
+__exportStar(require("./dto/create-documents.dto"), exports);
+__exportStar(require("./dto/query-pagination.dto"), exports);
+__exportStar(require("./dto/update-document.dto"), exports);
+__exportStar(require("./dto/attach-document-to-entity.dto"), exports);

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

@@ -0,0 +1,13 @@
+export interface IDocumentsCreationAttrs {
+    name: string;
+    path: string;
+    hash: string;
+}
+export interface ICreateArrDocumens {
+    type: string;
+    version: number;
+    description: string;
+    name: string;
+    newVersion: boolean;
+    ava?: boolean;
+}

package/dist/document/interfaces/interface.js

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

package/dist/document/schemas/documentsSchema.d.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { ModelUser } from '../../user';
+import { ModelMaterial } from '../../material';
+import { ModelProviders } from '../../provider';
+import { ModelEquipment } from '../../equipment';
+import { ModelInstrument } from '../../instrument';
+import { ModelInventary } from '../../inventary';
+import { ModelDetal } from '../../detal';
+import { ModelBuyer } from '../../buyer';
+import { ModelProduct } from '../../product';
+import { ModelCbed } from '../../cbed';
+import { ModelActions } from '../../action/schemas/actions.schema';
+import { ModelDeliveries } from '../../deliveries';
+import { ModelShComplit, ModelShipments } from '../../shipments';
+import { ModelOperation } from '../../operations';
+import { ModelAssembleKit } from '../../assemble-kit';
+import { ModelMoving } from '../../moving';
+import { ModelTechProcess } from '../../tech-process';
+import { ModelWaybill } from '../../waybill';
+import { ModelCompany } from '../../company';
+export declare const DocumentsSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    name: z.ZodString;
+    path: z.ZodString;
+    type: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodDefault<z.ZodNumber>;
+    ban: z.ZodDefault<z.ZodBoolean>;
+    ava: z.ZodDefault<z.ZodBoolean>;
+    sync_s3: z.ZodDefault<z.ZodBoolean>;
+    hash: z.ZodOptional<z.ZodString>;
+    responsible_user_id: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    ban: boolean;
+    name: string;
+    version: number;
+    ava: boolean;
+    sync_s3: boolean;
+    responsible_user_id: number | null;
+    type?: string | undefined;
+    description?: string | undefined;
+    id?: number | null | undefined;
+    hash?: string | undefined;
+}, {
+    path: string;
+    name: string;
+    responsible_user_id: number | null;
+    type?: string | undefined;
+    ban?: boolean | undefined;
+    description?: string | undefined;
+    id?: number | null | undefined;
+    version?: number | undefined;
+    ava?: boolean | undefined;
+    sync_s3?: boolean | undefined;
+    hash?: string | undefined;
+}>;
+export type ModelDocuments = z.infer<typeof DocumentsSchema> & {
+    users?: ModelUser[];
+    materials?: ModelMaterial[];
+    providers?: ModelProviders[];
+    companies?: ModelCompany[];
+    equipments?: ModelEquipment[];
+    instrument?: ModelInstrument[];
+    inventary?: ModelInventary[];
+    detals?: ModelDetal[];
+    buyers?: ModelBuyer[];
+    products?: ModelProduct[];
+    cbeds?: ModelCbed[];
+    actions?: ModelActions[];
+    deliveries?: ModelDeliveries[];
+    shipments?: ModelShipments[];
+    operations?: ModelOperation[];
+    assemble_kits?: ModelAssembleKit[];
+    movings?: ModelMoving[];
+    sh_complits?: ModelShComplit[];
+    tech_processis?: ModelTechProcess[];
+    waybills?: ModelWaybill[];
+};

package/dist/document/schemas/documentsSchema.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentsSchema = void 0;
+const zod_1 = require("zod");
+exports.DocumentsSchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    name: zod_1.z.string().min(1, { message: 'Название файла обязательно' }),
+    path: zod_1.z.string().min(1, { message: 'Путь обязателен' }),
+    type: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    version: zod_1.z.number().int().positive().default(1),
+    ban: zod_1.z.boolean().default(false),
+    ava: zod_1.z.boolean().default(false),
+    sync_s3: zod_1.z.boolean().default(false),
+    hash: zod_1.z.string().optional(),
+    responsible_user_id: zod_1.z.number().int().positive().nullable()
+});

package/dist/edizm/enum/enum.d.ts

@@ -0,0 +1,15 @@
+import { UnitsEnum } from '../../utils';
+export declare const EdizmIdByName: {
+    шт: number;
+    л: number;
+    кг: number;
+    м: number;
+    "\u043C.\u043A\u0443\u0431": number;
+};
+export declare const EdizmNameById: {
+    1: UnitsEnum;
+    2: UnitsEnum;
+    3: UnitsEnum;
+    4: UnitsEnum;
+    5: UnitsEnum;
+};

package/dist/edizm/enum/enum.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdizmNameById = exports.EdizmIdByName = void 0;
+const utils_1 = require("../../utils");
+exports.EdizmIdByName = {
+    [utils_1.UnitsEnum.pc]: 1,
+    [utils_1.UnitsEnum.l]: 2,
+    [utils_1.UnitsEnum.kg]: 3,
+    [utils_1.UnitsEnum.m]: 4,
+    [utils_1.UnitsEnum.mCub]: 5
+};
+exports.EdizmNameById = {
+    1: utils_1.UnitsEnum.pc,
+    2: utils_1.UnitsEnum.l,
+    3: utils_1.UnitsEnum.kg,
+    4: utils_1.UnitsEnum.m,
+    5: utils_1.UnitsEnum.mCub
+};

package/dist/edizm/index.d.ts

@@ -0,0 +1,5 @@
+export * from './schemas/edizm.schema';
+export * from './schemas/type-edizm.schema';
+export * from './schemas/unit-type-edizm.schema';
+export * from './interfaces/interface';
+export * from './enum/enum';

package/dist/edizm/index.js

@@ -0,0 +1,21 @@
+"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/edizm.schema"), exports);
+__exportStar(require("./schemas/type-edizm.schema"), exports);
+__exportStar(require("./schemas/unit-type-edizm.schema"), exports);
+__exportStar(require("./interfaces/interface"), exports);
+__exportStar(require("./enum/enum"), exports);

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

@@ -0,0 +1,8 @@
+export interface ITypeEdizmCreationAttrs {
+    name: string;
+}
+export interface IEdizmCreationAttrs {
+    name: string;
+    short_name: string;
+    typeEdizmId: number;
+}

package/dist/edizm/interfaces/interface.js

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

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ModelTypeEdizm } from './type-edizm.schema';
+export declare const EdizmSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    short_name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    name: string;
+    short_name: string;
+}, {
+    id: number;
+    name: string;
+    short_name: string;
+}>;
+export type ModelEdizm = z.infer<typeof EdizmSchema> & {
+    type_edizm?: ModelTypeEdizm[];
+};

package/dist/edizm/schemas/edizm.schema.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdizmSchema = void 0;
+const zod_1 = require("zod");
+exports.EdizmSchema = zod_1.z.object({
+    id: zod_1.z.number().int(),
+    name: zod_1.z.string(),
+    short_name: zod_1.z.string()
+});

package/dist/edizm/schemas/type-edizm.schema.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare const TypeEdizmSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    edizm: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        short_name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        name: string;
+        short_name: string;
+    }, {
+        id: number;
+        name: string;
+        short_name: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    name: string;
+    edizm: {
+        id: number;
+        name: string;
+        short_name: string;
+    }[];
+}, {
+    id: number;
+    name: string;
+    edizm: {
+        id: number;
+        name: string;
+        short_name: string;
+    }[];
+}>;
+export type ModelTypeEdizm = z.infer<typeof TypeEdizmSchema>;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeEdizmSchema = void 0;
+const zod_1 = require("zod");
+const edizm_schema_1 = require("./edizm.schema");
+exports.TypeEdizmSchema = zod_1.z.object({
+    id: zod_1.z.number().int(),
+    name: zod_1.z.string(),
+    edizm: zod_1.z.array(edizm_schema_1.EdizmSchema)
+});

package/dist/edizm/schemas/unit-type-edizm.schema.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const UnitsLinksSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    type_edizm_id: z.ZodNumber;
+    edizm_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    type_edizm_id: number;
+    edizm_id: number;
+}, {
+    id: number;
+    type_edizm_id: number;
+    edizm_id: number;
+}>;
+export type ModelUnitsLinks = z.infer<typeof UnitsLinksSchema>;

package/dist/edizm/schemas/unit-type-edizm.schema.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitsLinksSchema = void 0;
+const zod_1 = require("zod");
+exports.UnitsLinksSchema = zod_1.z.object({
+    id: zod_1.z.number().int(),
+    type_edizm_id: zod_1.z.number().int(),
+    edizm_id: zod_1.z.number().int()
+});