@pksep/zod-shared 0.0.552 → 0.0.553

package/dist/index.d.ts

@@ -39,3 +39,4 @@ export * from './supply';
 export * from './thread';
 export * from './movement-error';
 export * from './exclusion';
+export * from './planning';

package/dist/index.js

@@ -55,3 +55,4 @@ __exportStar(require("./supply"), exports);
 __exportStar(require("./thread"), exports);
 __exportStar(require("./movement-error"), exports);
 __exportStar(require("./exclusion"), exports);
+__exportStar(require("./planning"), exports);

package/dist/issue/dto/up-create-issue.dto.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { StatusIssue } from '../../utils';
+export declare const UpCreateIssueDtoZod: z.ZodObject<{
+    description: z.ZodString;
+    dateUse: z.ZodString;
+    normTime: z.ZodString;
+    sourse: z.ZodString;
+    srok: z.ZodString;
+    status: z.ZodNativeEnum<typeof StatusIssue>;
+    controllerList: z.ZodString;
+    executorList: z.ZodString;
+    izdList: z.ZodString;
+    shopNeeds: z.ZodString;
+    fileArrModal: z.ZodString;
+    srok_control: z.ZodString;
+    id: z.ZodNumber;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: StatusIssue;
+    id: number;
+    name: string;
+    description: string;
+    dateUse: string;
+    normTime: string;
+    sourse: string;
+    srok: string;
+    controllerList: string;
+    executorList: string;
+    srok_control: string;
+    izdList: string;
+    shopNeeds: string;
+    fileArrModal: string;
+}, {
+    status: StatusIssue;
+    id: number;
+    name: string;
+    description: string;
+    dateUse: string;
+    normTime: string;
+    sourse: string;
+    srok: string;
+    controllerList: string;
+    executorList: string;
+    srok_control: string;
+    izdList: string;
+    shopNeeds: string;
+    fileArrModal: string;
+}>;
+export type UpCreateIssueDtoType = z.infer<typeof UpCreateIssueDtoZod>;

package/dist/issue/dto/up-create-issue.dto.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpCreateIssueDtoZod = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.UpCreateIssueDtoZod = zod_1.z.object({
+    description: zod_1.z.string(),
+    dateUse: zod_1.z.string(),
+    normTime: zod_1.z.string(),
+    sourse: zod_1.z.string(),
+    srok: zod_1.z.string(),
+    status: zod_1.z.nativeEnum(utils_1.StatusIssue),
+    controllerList: zod_1.z.string(),
+    executorList: zod_1.z.string(),
+    izdList: zod_1.z.string(),
+    shopNeeds: zod_1.z.string(),
+    fileArrModal: zod_1.z.string(),
+    srok_control: zod_1.z.string(),
+    id: zod_1.z.number(),
+    name: zod_1.z.string()
+});

package/dist/issue/index.d.ts

@@ -0,0 +1,5 @@
+export * from './schemas/issue.schema';
+export * from './schemas/issue-user.schema';
+export * from './schemas/issue-user-controller.schema';
+export * from './interfaces/interface';
+export * from './dto/up-create-issue.dto';

package/dist/issue/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/issue.schema"), exports);
+__exportStar(require("./schemas/issue-user.schema"), exports);
+__exportStar(require("./schemas/issue-user-controller.schema"), exports);
+__exportStar(require("./interfaces/interface"), exports);
+__exportStar(require("./dto/up-create-issue.dto"), exports);

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

@@ -0,0 +1,4 @@
+export interface IIssueCreationAttrs {
+    name: string;
+    instans: number;
+}

package/dist/issue/schemas/issue-user-controller.schema.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const issueUserControllerSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    issueId: z.ZodNumber;
+    userId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    userId: number;
+    issueId: number;
+    id?: number | null | undefined;
+}, {
+    userId: number;
+    issueId: number;
+    id?: number | null | undefined;
+}>;
+export type ModelIssueUserController = z.infer<typeof issueUserControllerSchema>;

package/dist/issue/schemas/issue-user-controller.schema.js

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

package/dist/issue/schemas/issue-user.schema.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const issueUserSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    issueId: z.ZodNumber;
+    userId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    userId: number;
+    issueId: number;
+    id?: number | null | undefined;
+}, {
+    userId: number;
+    issueId: number;
+    id?: number | null | undefined;
+}>;
+export type ModelissueUser = z.infer<typeof issueUserSchema>;

package/dist/issue/schemas/issue-user.schema.js

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

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const IssueSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    dateUse: z.ZodOptional<z.ZodString>;
+    normTime: z.ZodOptional<z.ZodString>;
+    sourse: z.ZodOptional<z.ZodString>;
+    srok: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    controllerList: z.ZodOptional<z.ZodString>;
+    executorList: z.ZodOptional<z.ZodString>;
+    srok_control: z.ZodOptional<z.ZodString>;
+    izdList: z.ZodOptional<z.ZodString>;
+    shopNeeds: z.ZodOptional<z.ZodString>;
+    instans: z.ZodDefault<z.ZodNumber>;
+    responsibleUserId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    instans: number;
+    status?: string | undefined;
+    id?: number | null | undefined;
+    description?: string | undefined;
+    responsibleUserId?: number | null | undefined;
+    dateUse?: string | undefined;
+    normTime?: string | undefined;
+    sourse?: string | undefined;
+    srok?: string | undefined;
+    controllerList?: string | undefined;
+    executorList?: string | undefined;
+    srok_control?: string | undefined;
+    izdList?: string | undefined;
+    shopNeeds?: string | undefined;
+}, {
+    name: string;
+    status?: string | undefined;
+    id?: number | null | undefined;
+    description?: string | undefined;
+    instans?: number | undefined;
+    responsibleUserId?: number | null | undefined;
+    dateUse?: string | undefined;
+    normTime?: string | undefined;
+    sourse?: string | undefined;
+    srok?: string | undefined;
+    controllerList?: string | undefined;
+    executorList?: string | undefined;
+    srok_control?: string | undefined;
+    izdList?: string | undefined;
+    shopNeeds?: string | undefined;
+}>;
+export type ModelIssue = z.infer<typeof IssueSchema>;

package/dist/issue/schemas/issue.schema.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueSchema = void 0;
+const zod_1 = require("zod");
+exports.IssueSchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    dateUse: zod_1.z.string().optional(),
+    normTime: zod_1.z.string().optional(),
+    sourse: zod_1.z.string().optional(),
+    srok: zod_1.z.string().optional(),
+    status: zod_1.z.string().optional(),
+    controllerList: zod_1.z.string().optional(),
+    executorList: zod_1.z.string().optional(),
+    srok_control: zod_1.z.string().optional(),
+    izdList: zod_1.z.string().optional(),
+    shopNeeds: zod_1.z.string().optional(),
+    instans: zod_1.z.number().int().positive().default(1),
+    responsibleUserId: zod_1.z.number().nullish()
+});

package/dist/library/dto/create-chapter.dto.d.ts

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

package/dist/library/dto/create-chapter.dto.js

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

package/dist/library/dto/create-link.dto.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const CreateLinkDtoZod: z.ZodObject<{
+    name: z.ZodString;
+    is_link: z.ZodString;
+    link: z.ZodString;
+    description: z.ZodString;
+    docs: z.ZodAny;
+    user_id: z.ZodNumber;
+    chapter_id: z.ZodNumber;
+    id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    name: string;
+    description: string;
+    user_id: number;
+    link: string;
+    is_link: string;
+    chapter_id: number;
+    docs?: any;
+}, {
+    id: number;
+    name: string;
+    description: string;
+    user_id: number;
+    link: string;
+    is_link: string;
+    chapter_id: number;
+    docs?: any;
+}>;
+export type CreateLinkDtoType = z.infer<typeof CreateLinkDtoZod>;

package/dist/library/dto/create-link.dto.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateLinkDtoZod = void 0;
+const zod_1 = require("zod");
+exports.CreateLinkDtoZod = zod_1.z.object({
+    name: zod_1.z.string(),
+    is_link: zod_1.z.string(),
+    link: zod_1.z.string(),
+    description: zod_1.z.string(),
+    docs: zod_1.z.any(),
+    user_id: zod_1.z.number(),
+    chapter_id: zod_1.z.number(),
+    id: zod_1.z.number()
+});

package/dist/library/index.d.ts

@@ -0,0 +1,5 @@
+export * from './schemas/links.schema';
+export * from './schemas/links-user.schema';
+export * from './interfaces/interface';
+export * from './dto/create-chapter.dto';
+export * from './dto/create-link.dto';

package/dist/library/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/links.schema"), exports);
+__exportStar(require("./schemas/links-user.schema"), exports);
+__exportStar(require("./interfaces/interface"), exports);
+__exportStar(require("./dto/create-chapter.dto"), exports);
+__exportStar(require("./dto/create-link.dto"), exports);

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

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

package/dist/library/interfaces/interface.js

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

package/dist/library/schemas/links-user.schema.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const LinksUserSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    links_id: z.ZodNumber;
+    user_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    user_id: number;
+    links_id: number;
+    id?: number | null | undefined;
+}, {
+    user_id: number;
+    links_id: number;
+    id?: number | null | undefined;
+}>;
+export type ModelLinksUser = z.infer<typeof LinksUserSchema>;

package/dist/library/schemas/links-user.schema.js

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

package/dist/library/schemas/links.schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const LinksSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    name: z.ZodString;
+    link: z.ZodOptional<z.ZodString>;
+    is_link: z.ZodBoolean;
+    ban: z.ZodDefault<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    responsible_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    chapter_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    ban: boolean;
+    name: string;
+    is_link: boolean;
+    id?: number | null | undefined;
+    description?: string | undefined;
+    responsible_id?: number | null | undefined;
+    link?: string | undefined;
+    chapter_id?: number | null | undefined;
+}, {
+    name: string;
+    is_link: boolean;
+    ban?: boolean | undefined;
+    id?: number | null | undefined;
+    description?: string | undefined;
+    responsible_id?: number | null | undefined;
+    link?: string | undefined;
+    chapter_id?: number | null | undefined;
+}>;
+export type ModelLinks = z.infer<typeof LinksSchema>;

package/dist/library/schemas/links.schema.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinksSchema = void 0;
+const zod_1 = require("zod");
+exports.LinksSchema = zod_1.z.object({
+    id: zod_1.z.number().nullish(),
+    name: zod_1.z.string(),
+    link: zod_1.z.string().optional(),
+    is_link: zod_1.z.boolean(),
+    ban: zod_1.z.boolean().default(false),
+    description: zod_1.z.string().optional(),
+    responsible_id: zod_1.z.number().nullish(),
+    chapter_id: zod_1.z.number().nullish()
+});

package/dist/planning/index.d.ts

@@ -0,0 +1 @@
+export * from './types/planning';

package/dist/planning/index.js

@@ -0,0 +1,17 @@
+"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("./types/planning"), exports);

package/dist/planning/types/planning.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+import { IShipmentCalculateObjecyt } from '../../shipments';
+import { IzdType, Neo4jEntityTypes, RecursiveGraphParentType, RecursiveGraphType } from '../../utils';
+export declare const CalculatePlanningSchema: z.ZodObject<{
+    itemId: z.ZodNumber;
+    itemType: z.ZodNativeEnum<typeof IzdType>;
+}, "strip", z.ZodTypeAny, {
+    itemId: number;
+    itemType: IzdType;
+}, {
+    itemId: number;
+    itemType: IzdType;
+}>;
+export type CalculatePlanningData = z.infer<typeof CalculatePlanningSchema>;
+export type PlanningGraphNode = {
+    itemId: number;
+    itemType: Neo4jEntityTypes;
+    isRelative: boolean;
+    hasPlanningOrder?: boolean;
+    childrens: PlanningGraphNode[];
+};
+export type PlanningGraphRelative = {
+    id: number;
+    type: Neo4jEntityTypes;
+};
+export declare const PlanningGraphNodeSchema: z.ZodType<PlanningGraphNode>;
+export declare const PlanningGraphRelativeSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodNativeEnum<typeof Neo4jEntityTypes>;
+}, "strip", z.ZodTypeAny, {
+    type: Neo4jEntityTypes;
+    id: number;
+}, {
+    type: Neo4jEntityTypes;
+    id: number;
+}>;
+export declare const PlanningGraphResponseSchema: z.ZodObject<{
+    itemId: z.ZodNumber;
+    itemType: z.ZodNativeEnum<typeof Neo4jEntityTypes>;
+    graph: z.ZodArray<z.ZodType<PlanningGraphNode, z.ZodTypeDef, PlanningGraphNode>, "many">;
+}, "strip", z.ZodTypeAny, {
+    graph: PlanningGraphNode[];
+    itemId: number;
+    itemType: Neo4jEntityTypes;
+}, {
+    graph: PlanningGraphNode[];
+    itemId: number;
+    itemType: Neo4jEntityTypes;
+}>;
+export interface PlanningRecursiveCountPerShipment {
+    quantityArr: Map<string, IShipmentCalculateObjecyt>;
+    relativeProduct: any;
+    entityToFindId: number;
+    shipmentKol: number;
+    entityType: IzdType.detal | IzdType.cbed | IzdType.material;
+}
+export type PlanningRecursiveGraphEntityType = IzdType.product | IzdType.cbed | IzdType.detal | IzdType.material;
+export type PlanningRecursiveGraphNode = RecursiveGraphType & {
+    id: number;
+    entity_type: PlanningRecursiveGraphEntityType;
+    quantity: number;
+    parent_id?: number;
+    parent_type?: PlanningRecursiveGraphEntityType;
+    count_to_obj?: number;
+    count_to_needs?: number;
+    needs?: number;
+    cbeds: PlanningRecursiveGraphNode[];
+    detals: PlanningRecursiveGraphNode[];
+    materials: PlanningRecursiveGraphNode[];
+    cbedGraph: PlanningRecursiveGraphNode[];
+    detalsGraph: PlanningRecursiveGraphNode[];
+    materialGraph: PlanningRecursiveGraphNode[];
+};
+export type PlanningRecursiveGraphTree = RecursiveGraphParentType & {
+    id: number;
+    entity_type: PlanningRecursiveGraphEntityType;
+    quantity: number;
+    cbeds: PlanningRecursiveGraphNode[];
+    detals: PlanningRecursiveGraphNode[];
+    materials: PlanningRecursiveGraphNode[];
+    cbedGraph: PlanningRecursiveGraphNode[];
+    detalsGraph: PlanningRecursiveGraphNode[];
+    materialGraph: PlanningRecursiveGraphNode[];
+};
+export type PlanningRecursiveCountByEntityShipment = Omit<PlanningRecursiveCountPerShipment, 'relativeProduct'> & {
+    relativeProduct: PlanningRecursiveGraphTree;
+    relativeProductType?: PlanningRecursiveGraphEntityType;
+};
+export type PlanningOrderDocumentType = 'shipment' | 'stock-order' | 'production-task';
+export type PlanningOrderDocument = {
+    documentType: PlanningOrderDocumentType;
+    documentId: number;
+    entityId: number;
+    entityType: PlanningRecursiveGraphEntityType;
+    entityName: string | null;
+    entityDesignation: string | null;
+    entityAvatar: string | null;
+    numberOrder: string | null;
+    orderDate: Date | string | null;
+    plannedShipmentDate: Date | string | null;
+    warehouseReadinessDate: Date | string | null;
+    quantity: number;
+    completedQuantity: number;
+    remainingQuantity: number;
+    status?: string | null;
+    stockOrderItemId?: number;
+    productionOperationPosId?: number;
+    productionTaskDocuments?: PlanningOrderDocument[];
+};
+export type PlanningOrderAccordionDocument = PlanningOrderDocument & {
+    coveredQuantity: number;
+};
+export type PlanningOrderAccordionNode = {
+    entityId: number;
+    entityType: PlanningRecursiveGraphEntityType;
+    entityName: string | null;
+    entityDesignation: string | null;
+    entityAvatar: string | null;
+    parentId: number | null;
+    parentType: PlanningRecursiveGraphEntityType | null;
+    countToNeeds: number | null;
+    needDate: Date | string | null;
+    sourceDocument: PlanningOrderDocument | null;
+    quantity: number;
+    stockQuantity: number;
+    stockCoveredQuantity: number;
+    afterStockQuantity: number;
+    stockOrderCoveredQuantity: number;
+    deficitQuantity: number;
+    isSurplus: boolean;
+    isCovered: boolean;
+    coverDocuments: PlanningOrderAccordionDocument[];
+    children: PlanningOrderAccordionNode[];
+};
+export type PlanningPeggingEntityKey = string;
+export type PlanningPeggingItem = {
+    key: PlanningPeggingEntityKey;
+    id: number;
+    type: PlanningRecursiveGraphEntityType;
+    name: string | null;
+    designation: string | null;
+    avatar: string | null;
+    stock: number;
+};
+export type PlanningPeggingSpec = {
+    parent: PlanningPeggingEntityKey;
+    child: PlanningPeggingEntityKey;
+    qty: number;
+};
+export type PlanningPeggingPathNode = {
+    item: PlanningPeggingEntityKey;
+    qty: number;
+    stockCov?: number;
+    afterStock?: number;
+    zsCov?: number;
+    deficit?: number;
+    isCovered?: boolean;
+    cover?: PlanningOrderAccordionDocument[];
+};
+export type PlanningPeggingBranch = {
+    branchKey: string;
+    qty: number;
+    needDate: Date | string | null;
+    origin: PlanningOrderDocument;
+    path: PlanningPeggingPathNode[];
+    surplus?: boolean;
+    _self?: boolean;
+    stockCov?: number;
+    afterStock?: number;
+    zsCov?: number;
+    deficit?: number;
+    cover?: PlanningOrderAccordionDocument[];
+};
+export type PlanningPeggingStockOrder = PlanningOrderDocument & {
+    left: number;
+    productionTaskDocuments: PlanningOrderDocument[];
+};

package/dist/planning/types/planning.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanningGraphResponseSchema = exports.PlanningGraphRelativeSchema = exports.PlanningGraphNodeSchema = exports.CalculatePlanningSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.CalculatePlanningSchema = zod_1.z.object({
+    itemId: zod_1.z.number().int().positive(),
+    itemType: zod_1.z.nativeEnum(utils_1.IzdType)
+});
+exports.PlanningGraphNodeSchema = zod_1.z.lazy(() => zod_1.z.object({
+    itemId: zod_1.z.number().int(),
+    itemType: zod_1.z.nativeEnum(utils_1.Neo4jEntityTypes),
+    isRelative: zod_1.z.boolean(),
+    hasPlanningOrder: zod_1.z.boolean().optional(),
+    childrens: zod_1.z.array(exports.PlanningGraphNodeSchema)
+}));
+exports.PlanningGraphRelativeSchema = zod_1.z.object({
+    id: zod_1.z.number().int(),
+    type: zod_1.z.nativeEnum(utils_1.Neo4jEntityTypes)
+});
+exports.PlanningGraphResponseSchema = zod_1.z.object({
+    itemId: zod_1.z.number().int(),
+    itemType: zod_1.z.nativeEnum(utils_1.Neo4jEntityTypes),
+    graph: zod_1.z.array(exports.PlanningGraphNodeSchema)
+});

package/dist/production-tasks/dto/update-marks.dto.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { IOperationPosition } from '../interfaces/production-tasks';
+export declare const UpdateProductionTaskMarksDtoZod: z.ZodObject<{
+    operationPosition: z.ZodOptional<z.ZodNullable<z.ZodType<IOperationPosition, z.ZodTypeDef, IOperationPosition>>>;
+    productionTaskId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    operationPosition?: IOperationPosition | null | undefined;
+    productionTaskId?: number | null | undefined;
+}, {
+    operationPosition?: IOperationPosition | null | undefined;
+    productionTaskId?: number | null | undefined;
+}>;
+export type UpdateProductionTaskMarksDtoZodType = z.infer<typeof UpdateProductionTaskMarksDtoZod>;