@pksep/zod-shared 0.0.563 → 0.0.564

package/dist/ai-mcp/schemas/ai-mcp-technology.schema.d.ts

@@ -0,0 +1,225 @@
+import * as z from 'zod/v4';
+export declare enum ErpTechnologyReferenceKindEnum {
+    operationType = "operationType",
+    equipment = "equipment",
+    instrument = "instrument",
+    tooling = "tooling",
+    measuringInstrument = "measuringInstrument"
+}
+export declare const ErpTechnologyGetInputShape: {
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+};
+export declare const ErpTechnologyReferenceSearchInputShape: {
+    kind: z.ZodEnum<typeof ErpTechnologyReferenceKindEnum>;
+    query: z.ZodDefault<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+};
+export declare const ErpTechnologyOperationAddInputShape: {
+    operationTypeName: z.ZodString;
+    position: z.ZodOptional<z.ZodNumber>;
+    mainTime: z.ZodDefault<z.ZodNumber>;
+    note: z.ZodDefault<z.ZodString>;
+    resources: z.ZodOptional<z.ZodObject<{
+        equipment: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        instruments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tooling: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        measuringInstruments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    idempotencyKey: z.ZodString;
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+};
+export declare const ErpTechnologyOperationUpdateInputShape: {
+    changes: z.ZodObject<{
+        operationTypeName: z.ZodOptional<z.ZodString>;
+        mainTime: z.ZodOptional<z.ZodNumber>;
+        note: z.ZodOptional<z.ZodString>;
+        resources: z.ZodOptional<z.ZodObject<{
+            equipment: z.ZodOptional<z.ZodObject<{
+                add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            instruments: z.ZodOptional<z.ZodObject<{
+                add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            tooling: z.ZodOptional<z.ZodObject<{
+                add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            measuringInstruments: z.ZodOptional<z.ZodObject<{
+                add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    idempotencyKey: z.ZodString;
+    operationName: z.ZodOptional<z.ZodString>;
+    operationPosition: z.ZodOptional<z.ZodNumber>;
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+};
+export declare const ErpTechnologyOperationMoveInputShape: {
+    position: z.ZodNumber;
+    idempotencyKey: z.ZodString;
+    operationName: z.ZodOptional<z.ZodString>;
+    operationPosition: z.ZodOptional<z.ZodNumber>;
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+};
+export declare const ErpTechnologyOperationRemoveInputShape: {
+    idempotencyKey: z.ZodString;
+    operationName: z.ZodOptional<z.ZodString>;
+    operationPosition: z.ZodOptional<z.ZodNumber>;
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+};
+export declare const ErpTechnologyProcessUpdateInputShape: {
+    note: z.ZodString;
+    idempotencyKey: z.ZodString;
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+};
+export declare const ErpTechnologyGetInputZod: z.ZodObject<{
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ErpTechnologyReferenceSearchInputZod: z.ZodObject<{
+    kind: z.ZodEnum<typeof ErpTechnologyReferenceKindEnum>;
+    query: z.ZodDefault<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ErpTechnologyOperationAddInputZod: z.ZodObject<{
+    operationTypeName: z.ZodString;
+    position: z.ZodOptional<z.ZodNumber>;
+    mainTime: z.ZodDefault<z.ZodNumber>;
+    note: z.ZodDefault<z.ZodString>;
+    resources: z.ZodOptional<z.ZodObject<{
+        equipment: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        instruments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tooling: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        measuringInstruments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    idempotencyKey: z.ZodString;
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ErpTechnologyOperationUpdateInputZod: z.ZodObject<{
+    changes: z.ZodObject<{
+        operationTypeName: z.ZodOptional<z.ZodString>;
+        mainTime: z.ZodOptional<z.ZodNumber>;
+        note: z.ZodOptional<z.ZodString>;
+        resources: z.ZodOptional<z.ZodObject<{
+            equipment: z.ZodOptional<z.ZodObject<{
+                add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            instruments: z.ZodOptional<z.ZodObject<{
+                add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            tooling: z.ZodOptional<z.ZodObject<{
+                add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            measuringInstruments: z.ZodOptional<z.ZodObject<{
+                add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    idempotencyKey: z.ZodString;
+    operationName: z.ZodOptional<z.ZodString>;
+    operationPosition: z.ZodOptional<z.ZodNumber>;
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ErpTechnologyOperationMoveInputZod: z.ZodObject<{
+    position: z.ZodNumber;
+    idempotencyKey: z.ZodString;
+    operationName: z.ZodOptional<z.ZodString>;
+    operationPosition: z.ZodOptional<z.ZodNumber>;
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ErpTechnologyOperationRemoveInputZod: z.ZodObject<{
+    idempotencyKey: z.ZodString;
+    operationName: z.ZodOptional<z.ZodString>;
+    operationPosition: z.ZodOptional<z.ZodNumber>;
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ErpTechnologyProcessUpdateInputZod: z.ZodObject<{
+    note: z.ZodString;
+    idempotencyKey: z.ZodString;
+    entityType: z.ZodEnum<{
+        product: import("../..").IzdType.product;
+        cbed: import("../..").IzdType.cbed;
+        detal: import("../..").IzdType.detal;
+    }>;
+    entityName: z.ZodOptional<z.ZodString>;
+    entityDesignation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TErpTechnologyGetInput = z.infer<typeof ErpTechnologyGetInputZod>;
+export type TErpTechnologyReferenceSearchInput = z.infer<typeof ErpTechnologyReferenceSearchInputZod>;
+export type TErpTechnologyOperationAddInput = z.infer<typeof ErpTechnologyOperationAddInputZod>;
+export type TErpTechnologyOperationUpdateInput = z.infer<typeof ErpTechnologyOperationUpdateInputZod>;
+export type TErpTechnologyOperationMoveInput = z.infer<typeof ErpTechnologyOperationMoveInputZod>;
+export type TErpTechnologyOperationRemoveInput = z.infer<typeof ErpTechnologyOperationRemoveInputZod>;
+export type TErpTechnologyProcessUpdateInput = z.infer<typeof ErpTechnologyProcessUpdateInputZod>;

package/dist/ai-mcp/schemas/ai-mcp-technology.schema.js

@@ -0,0 +1,156 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErpTechnologyProcessUpdateInputZod = exports.ErpTechnologyOperationRemoveInputZod = exports.ErpTechnologyOperationMoveInputZod = exports.ErpTechnologyOperationUpdateInputZod = exports.ErpTechnologyOperationAddInputZod = exports.ErpTechnologyReferenceSearchInputZod = exports.ErpTechnologyGetInputZod = exports.ErpTechnologyProcessUpdateInputShape = exports.ErpTechnologyOperationRemoveInputShape = exports.ErpTechnologyOperationMoveInputShape = exports.ErpTechnologyOperationUpdateInputShape = exports.ErpTechnologyOperationAddInputShape = exports.ErpTechnologyReferenceSearchInputShape = exports.ErpTechnologyGetInputShape = exports.ErpTechnologyReferenceKindEnum = void 0;
+const z = __importStar(require("zod/v4"));
+const ai_mcp_schema_1 = require("./ai-mcp.schema");
+var ErpTechnologyReferenceKindEnum;
+(function (ErpTechnologyReferenceKindEnum) {
+    ErpTechnologyReferenceKindEnum["operationType"] = "operationType";
+    ErpTechnologyReferenceKindEnum["equipment"] = "equipment";
+    ErpTechnologyReferenceKindEnum["instrument"] = "instrument";
+    ErpTechnologyReferenceKindEnum["tooling"] = "tooling";
+    ErpTechnologyReferenceKindEnum["measuringInstrument"] = "measuringInstrument";
+})(ErpTechnologyReferenceKindEnum || (exports.ErpTechnologyReferenceKindEnum = ErpTechnologyReferenceKindEnum = {}));
+const idempotencyKeyZod = z
+    .string()
+    .trim()
+    .min(8)
+    .max(128)
+    .regex(/^[a-zA-Z0-9._:-]+$/);
+const entityReferenceShape = {
+    entityType: ai_mcp_schema_1.AiMcpEntityTypeZod,
+    entityName: z.string().trim().min(1).max(255).optional(),
+    entityDesignation: z.string().trim().min(1).max(255).optional()
+};
+const operationReferenceShape = {
+    operationName: z.string().trim().min(1).max(255).optional(),
+    operationPosition: z.number().int().min(1).optional()
+};
+const resourceNamesZod = z.array(z.string().trim().min(1).max(255)).max(20);
+const hasNames = (names) => Boolean(names === null || names === void 0 ? void 0 : names.length);
+const resourceSelectionZod = z
+    .object({
+    equipment: resourceNamesZod.optional(),
+    instruments: resourceNamesZod.optional(),
+    tooling: resourceNamesZod.optional(),
+    measuringInstruments: resourceNamesZod.optional()
+})
+    .refine(resources => Object.values(resources).some(hasNames), {
+    message: 'Укажите хотя бы один производственный ресурс.'
+});
+const resourceMutationZod = z
+    .object({
+    add: resourceNamesZod.optional(),
+    remove: resourceNamesZod.optional()
+})
+    .refine(change => hasNames(change.add) || hasNames(change.remove), {
+    message: 'Укажите ресурсы для добавления или удаления.'
+});
+const resourceChangesZod = z.object({
+    equipment: resourceMutationZod.optional(),
+    instruments: resourceMutationZod.optional(),
+    tooling: resourceMutationZod.optional(),
+    measuringInstruments: resourceMutationZod.optional()
+});
+const validateEntityReference = (input, context) => {
+    if (!input.entityName && !input.entityDesignation) {
+        context.addIssue({
+            code: 'custom',
+            path: ['entityName'],
+            message: 'Укажите название или обозначение сущности ERP.'
+        });
+    }
+};
+const validateOperationReference = (input, context) => {
+    if (!input.operationName && !input.operationPosition) {
+        context.addIssue({
+            code: 'custom',
+            path: ['operationName'],
+            message: 'Укажите название или позицию операции.'
+        });
+    }
+};
+exports.ErpTechnologyGetInputShape = entityReferenceShape;
+exports.ErpTechnologyReferenceSearchInputShape = {
+    kind: z.nativeEnum(ErpTechnologyReferenceKindEnum),
+    query: z.string().trim().max(200).default(''),
+    limit: z.number().int().min(1).max(20).default(10)
+};
+exports.ErpTechnologyOperationAddInputShape = Object.assign(Object.assign({}, entityReferenceShape), { operationTypeName: z.string().trim().min(1).max(255), position: z.number().int().min(1).optional(), mainTime: z.number().min(0).max(1000000).default(0), note: z.string().max(4000).default(''), resources: resourceSelectionZod.optional(), idempotencyKey: idempotencyKeyZod });
+exports.ErpTechnologyOperationUpdateInputShape = Object.assign(Object.assign(Object.assign({}, entityReferenceShape), operationReferenceShape), { changes: z.object({
+        operationTypeName: z.string().trim().min(1).max(255).optional(),
+        mainTime: z.number().min(0).max(1000000).optional(),
+        note: z.string().max(4000).optional(),
+        resources: resourceChangesZod.optional()
+    }), idempotencyKey: idempotencyKeyZod });
+exports.ErpTechnologyOperationMoveInputShape = Object.assign(Object.assign(Object.assign({}, entityReferenceShape), operationReferenceShape), { position: z.number().int().min(1), idempotencyKey: idempotencyKeyZod });
+exports.ErpTechnologyOperationRemoveInputShape = Object.assign(Object.assign(Object.assign({}, entityReferenceShape), operationReferenceShape), { idempotencyKey: idempotencyKeyZod });
+exports.ErpTechnologyProcessUpdateInputShape = Object.assign(Object.assign({}, entityReferenceShape), { note: z.string().max(4000), idempotencyKey: idempotencyKeyZod });
+exports.ErpTechnologyGetInputZod = z
+    .object(exports.ErpTechnologyGetInputShape)
+    .superRefine(validateEntityReference);
+exports.ErpTechnologyReferenceSearchInputZod = z.object(exports.ErpTechnologyReferenceSearchInputShape);
+exports.ErpTechnologyOperationAddInputZod = z
+    .object(exports.ErpTechnologyOperationAddInputShape)
+    .superRefine(validateEntityReference);
+exports.ErpTechnologyOperationUpdateInputZod = z
+    .object(exports.ErpTechnologyOperationUpdateInputShape)
+    .superRefine((input, context) => {
+    validateEntityReference(input, context);
+    validateOperationReference(input, context);
+    if (Object.keys(input.changes).length === 0) {
+        context.addIssue({
+            code: 'custom',
+            path: ['changes'],
+            message: 'Укажите хотя бы одно изменение операции.'
+        });
+    }
+});
+exports.ErpTechnologyOperationMoveInputZod = z
+    .object(exports.ErpTechnologyOperationMoveInputShape)
+    .superRefine((input, context) => {
+    validateEntityReference(input, context);
+    validateOperationReference(input, context);
+});
+exports.ErpTechnologyOperationRemoveInputZod = z
+    .object(exports.ErpTechnologyOperationRemoveInputShape)
+    .superRefine((input, context) => {
+    validateEntityReference(input, context);
+    validateOperationReference(input, context);
+});
+exports.ErpTechnologyProcessUpdateInputZod = z
+    .object(exports.ErpTechnologyProcessUpdateInputShape)
+    .superRefine(validateEntityReference);

package/dist/ai-mcp/schemas/ai-mcp.schema.d.ts

@@ -7,13 +7,16 @@ export declare enum AiMcpOperationStatusEnum {
 export declare enum AiMcpOperationNameEnum {
     createDetailAndAddToCbed = "create-detail-and-add-to-cbed",
     archiveDetail = "archive-detail",
+    mutateSpecification = "mutate-specification",
     uploadAndAttachEntityDocument = "upload-and-attach-entity-document",
     attachEntityDocument = "attach-entity-document",
     detachEntityDocument = "detach-entity-document",
     setMainEntityDocument = "set-main-entity-document",
     updateDocument = "update-document",
     archiveDocument = "archive-document",
-    restoreDocument = "restore-document"
+    restoreDocument = "restore-document",
+    updateEntityEditor = "update-entity-editor",
+    mutateTechnology = "mutate-technology"
 }
 export declare enum AiMcpCommandStatusEnum {
     queued = "queued"

package/dist/ai-mcp/schemas/ai-mcp.schema.js

@@ -45,6 +45,7 @@ var AiMcpOperationNameEnum;
 (function (AiMcpOperationNameEnum) {
     AiMcpOperationNameEnum["createDetailAndAddToCbed"] = "create-detail-and-add-to-cbed";
     AiMcpOperationNameEnum["archiveDetail"] = "archive-detail";
+    AiMcpOperationNameEnum["mutateSpecification"] = "mutate-specification";
     AiMcpOperationNameEnum["uploadAndAttachEntityDocument"] = "upload-and-attach-entity-document";
     AiMcpOperationNameEnum["attachEntityDocument"] = "attach-entity-document";
     AiMcpOperationNameEnum["detachEntityDocument"] = "detach-entity-document";
@@ -52,6 +53,8 @@ var AiMcpOperationNameEnum;
     AiMcpOperationNameEnum["updateDocument"] = "update-document";
     AiMcpOperationNameEnum["archiveDocument"] = "archive-document";
     AiMcpOperationNameEnum["restoreDocument"] = "restore-document";
+    AiMcpOperationNameEnum["updateEntityEditor"] = "update-entity-editor";
+    AiMcpOperationNameEnum["mutateTechnology"] = "mutate-technology";
 })(AiMcpOperationNameEnum || (exports.AiMcpOperationNameEnum = AiMcpOperationNameEnum = {}));
 var AiMcpCommandStatusEnum;
 (function (AiMcpCommandStatusEnum) {
@@ -179,7 +182,9 @@ exports.ErpEntityFilesListInputShape = {
 };
 exports.ErpFilesSearchInputShape = {
     query: z.string().trim().min(1).max(200),
-    state: z.nativeEnum(ErpDocumentStateEnum).default(ErpDocumentStateEnum.active),
+    state: z
+        .nativeEnum(ErpDocumentStateEnum)
+        .default(ErpDocumentStateEnum.active),
     limit: z.number().int().min(1).max(20).default(10)
 };
 exports.ErpEntityFileAttachInputShape = Object.assign(Object.assign(Object.assign({}, erpDocumentEntityReferenceShape), erpDocumentReferenceShape), { makeMain: z.boolean().default(false), idempotencyKey: idempotencyKeyZod });

package/dist/bull-queue/index.d.ts

@@ -0,0 +1 @@
+export * from './schemas/queue-ownership.schema';

package/dist/bull-queue/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("./schemas/queue-ownership.schema"), exports);

package/dist/bull-queue/schemas/queue-ownership.schema.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+export declare const QueueOwnershipKeysSchema: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+export declare const QueueOwnershipBatchIdSchema: z.ZodString;
+export declare const QueueOwnershipReservationSchema: z.ZodObject<{
+    batchId: z.ZodString;
+    ownershipKeys: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+}, "strip", z.ZodTypeAny, {
+    batchId: string;
+    ownershipKeys: string[];
+}, {
+    batchId: string;
+    ownershipKeys: string[];
+}>;
+export declare const QueueOwnershipClaimSchema: z.ZodObject<{
+    registered: z.ZodBoolean;
+    batchId: z.ZodNullable<z.ZodString>;
+    ownershipKeys: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+}, "strip", z.ZodTypeAny, {
+    batchId: string | null;
+    ownershipKeys: string[];
+    registered: boolean;
+}, {
+    batchId: string | null;
+    ownershipKeys: string[];
+    registered: boolean;
+}>;
+export declare const QueueOwnershipJobProgressSchema: z.ZodObject<{
+    stage: z.ZodLiteral<"deduplication">;
+    status: z.ZodEnum<["processed", "partially_skipped", "skipped"]>;
+    requestedData: z.ZodUnknown;
+    processedData: z.ZodUnknown;
+    skippedData: z.ZodUnknown;
+    reason: z.ZodNullable<z.ZodLiteral<"superseded_by_newer_job">>;
+}, "strip", z.ZodTypeAny, {
+    status: "processed" | "partially_skipped" | "skipped";
+    stage: "deduplication";
+    reason: "superseded_by_newer_job" | null;
+    requestedData?: unknown;
+    processedData?: unknown;
+    skippedData?: unknown;
+}, {
+    status: "processed" | "partially_skipped" | "skipped";
+    stage: "deduplication";
+    reason: "superseded_by_newer_job" | null;
+    requestedData?: unknown;
+    processedData?: unknown;
+    skippedData?: unknown;
+}>;
+export declare const ProductDeficitConcurrencyTestResultSchema: z.ZodObject<{
+    productId: z.ZodNumber;
+    overlapProductId: z.ZodNumber;
+    requestedJobs: z.ZodNumber;
+    createdJobs: z.ZodNumber;
+    jobIds: z.ZodArray<z.ZodString, "many">;
+    submittedPayloads: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
+}, "strip", z.ZodTypeAny, {
+    productId: number;
+    overlapProductId: number;
+    requestedJobs: number;
+    createdJobs: number;
+    jobIds: string[];
+    submittedPayloads: number[][];
+}, {
+    productId: number;
+    overlapProductId: number;
+    requestedJobs: number;
+    createdJobs: number;
+    jobIds: string[];
+    submittedPayloads: number[][];
+}>;
+export type QueueOwnershipReservation = z.infer<typeof QueueOwnershipReservationSchema>;
+export type QueueOwnershipClaim = z.infer<typeof QueueOwnershipClaimSchema>;
+export type QueueOwnershipJobProgress = z.infer<typeof QueueOwnershipJobProgressSchema>;
+export type ProductDeficitConcurrencyTestResult = z.infer<typeof ProductDeficitConcurrencyTestResultSchema>;

package/dist/bull-queue/schemas/queue-ownership.schema.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductDeficitConcurrencyTestResultSchema = exports.QueueOwnershipJobProgressSchema = exports.QueueOwnershipClaimSchema = exports.QueueOwnershipReservationSchema = exports.QueueOwnershipBatchIdSchema = exports.QueueOwnershipKeysSchema = void 0;
+const zod_1 = require("zod");
+exports.QueueOwnershipKeysSchema = zod_1.z
+    .array(zod_1.z.string().trim().min(1))
+    .transform(ownershipKeys => Array.from(new Set(ownershipKeys)));
+exports.QueueOwnershipBatchIdSchema = zod_1.z.string().uuid();
+exports.QueueOwnershipReservationSchema = zod_1.z.object({
+    batchId: exports.QueueOwnershipBatchIdSchema,
+    ownershipKeys: exports.QueueOwnershipKeysSchema
+});
+exports.QueueOwnershipClaimSchema = zod_1.z.object({
+    registered: zod_1.z.boolean(),
+    batchId: exports.QueueOwnershipBatchIdSchema.nullable(),
+    ownershipKeys: exports.QueueOwnershipKeysSchema
+});
+exports.QueueOwnershipJobProgressSchema = zod_1.z.object({
+    stage: zod_1.z.literal('deduplication'),
+    status: zod_1.z.enum(['processed', 'partially_skipped', 'skipped']),
+    requestedData: zod_1.z.unknown(),
+    processedData: zod_1.z.unknown(),
+    skippedData: zod_1.z.unknown(),
+    reason: zod_1.z.literal('superseded_by_newer_job').nullable()
+});
+exports.ProductDeficitConcurrencyTestResultSchema = zod_1.z.object({
+    productId: zod_1.z.number().int().positive(),
+    overlapProductId: zod_1.z.number().int().positive(),
+    requestedJobs: zod_1.z.number().int().positive(),
+    createdJobs: zod_1.z.number().int().nonnegative(),
+    jobIds: zod_1.z.array(zod_1.z.string()),
+    submittedPayloads: zod_1.z.array(zod_1.z.array(zod_1.z.number().int().positive()))
+});

package/dist/deficit/index.d.ts

@@ -1,4 +1,5 @@
 export * from './schemas/deficit.schema';
+export * from './schemas/deficit-queue.schema';
 export * from './interfaces/interface';
 export * from './dto/create-deficite.dto';
 export * from './dto/deficit-material.dto';

package/dist/deficit/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./schemas/deficit.schema"), exports);
+__exportStar(require("./schemas/deficit-queue.schema"), exports);
 __exportStar(require("./interfaces/interface"), exports);
 __exportStar(require("./dto/create-deficite.dto"), exports);
 __exportStar(require("./dto/deficit-material.dto"), exports);

package/dist/deficit/schemas/deficit-queue.schema.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const DeficitQueueEntityIdsSchema: z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>;

package/dist/deficit/schemas/deficit-queue.schema.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeficitQueueEntityIdsSchema = void 0;
+const zod_1 = require("zod");
+exports.DeficitQueueEntityIdsSchema = zod_1.z
+    .array(zod_1.z.coerce.number().int().positive())
+    .transform(entityIds => Array.from(new Set(entityIds)));