@floristcloud/api-lib 1.2.160 → 1.2.162

package/schemas/parser/process-parse-batch-s2s-request.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+// Парсер шлёт батч из нескольких страниц каталога (сейчас 4 страницы): с запасом, но не безгранично.
+const PARSE_BATCH_MAX_ELEMENTS = 500;
+
+export const ProcessParseBatchS2SRequestSchema = z.object({
+    parseUUID: z.string().uuid(),
+    batchElements: z.array(z.unknown()).max(PARSE_BATCH_MAX_ELEMENTS),
+});

package/schemas/parser/process-parse-batch-s2s-response.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { ParseBatchAcceptedElementSchema } from './parse-batch-accepted-element.schema';
+
+export const ProcessParseBatchS2SResponseSchema = z.object({
+    isSuccess: z.boolean(),
+    createdCount: z.number().int(),
+    updatedCount: z.number().int(),
+    accepted: z.array(ParseBatchAcceptedElementSchema),
+});

package/schemas/parser/start-ozexport-job-base.shape.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { OzexportAccountUnitSchema } from '../integration/ozexport/ozexport-account-unit.schema';
+import { OzexportJobAttemptSchema } from './ozexport-job-attempt.schema';
+import { OzexportJobCredentialsSchema } from './ozexport-job-credentials.schema';
+
+export const StartOzexportJobBaseShape = {
+    jobId: z.uuid(),
+    attempt: OzexportJobAttemptSchema,
+    // Только в теле запроса; не логировать и не сохранять (см. OzexportJobCredentialsSchema).
+    credentials: OzexportJobCredentialsSchema,
+    // Юнит покупателя; null — основной юнит, без переключения (в первой версии всегда null).
+    unitUid: OzexportAccountUnitSchema.shape.uid.nullable(),
+    // После дедлайна обход прекращается, но complete всё равно отправляется.
+    deadlineAt: z.iso.datetime(),
+};

package/schemas/parser/start-ozexport-job-s2s-request-account-crawl.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { SupplierSyncJobKindEnum } from '../../enum/supplier-sync-job-kind.enum';
+import { StartOzexportJobBaseShape } from './start-ozexport-job-base.shape';
+
+export const StartOzexportJobS2SRequestAccountCrawlSchema = z.object({
+    ...StartOzexportJobBaseShape,
+    kind: z.literal(SupplierSyncJobKindEnum.ACCOUNT_CRAWL),
+});

package/schemas/parser/start-ozexport-job-s2s-request-offers-refresh.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { SupplierSyncJobKindEnum } from '../../enum/supplier-sync-job-kind.enum';
+import { OzexportRefreshOfferSchema } from './ozexport-refresh-offer.schema';
+import { StartOzexportJobBaseShape } from './start-ozexport-job-base.shape';
+
+const OZEXPORT_REFRESH_OFFERS_MAX = 1000;
+
+export const StartOzexportJobS2SRequestOffersRefreshSchema = z.object({
+    ...StartOzexportJobBaseShape,
+    kind: z.literal(SupplierSyncJobKindEnum.OFFERS_REFRESH),
+    offers: z.array(OzexportRefreshOfferSchema).min(1).max(OZEXPORT_REFRESH_OFFERS_MAX),
+});

package/schemas/parser/start-ozexport-job-s2s-request.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { StartOzexportJobS2SRequestAccountCrawlSchema } from './start-ozexport-job-s2s-request-account-crawl.schema';
+import { StartOzexportJobS2SRequestOffersRefreshSchema } from './start-ozexport-job-s2s-request-offers-refresh.schema';
+
+// Повтор start по (jobId, attempt) идемпотентен: таймаут API не создаёт вторую попытку и даёт ALREADY_RUNNING.
+export const StartOzexportJobS2SRequestSchema = z.discriminatedUnion('kind', [
+    StartOzexportJobS2SRequestAccountCrawlSchema,
+    StartOzexportJobS2SRequestOffersRefreshSchema,
+]);

package/schemas/parser/start-ozexport-job-s2s-response-already-running.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+
+export const StartOzexportJobS2SResponseAlreadyRunningSchema = z.object({
+    outcome: z.literal(OzexportJobStartOutcomeEnum.ALREADY_RUNNING),
+});

package/schemas/parser/start-ozexport-job-s2s-response-busy.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+
+export const StartOzexportJobS2SResponseBusySchema = z.object({ outcome: z.literal(OzexportJobStartOutcomeEnum.BUSY) });

package/schemas/parser/start-ozexport-job-s2s-response-finished.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+import { OzexportJobResultSchema } from './ozexport-job-result.schema';
+
+export const StartOzexportJobS2SResponseFinishedSchema = z.object({
+    outcome: z.literal(OzexportJobStartOutcomeEnum.FINISHED),
+    result: OzexportJobResultSchema,
+});

package/schemas/parser/start-ozexport-job-s2s-response-paused.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+
+export const StartOzexportJobS2SResponsePausedSchema = z.object({
+    outcome: z.literal(OzexportJobStartOutcomeEnum.PAUSED),
+    pausedUntil: z.iso.datetime(),
+});

package/schemas/parser/start-ozexport-job-s2s-response-shutting-down.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+
+export const StartOzexportJobS2SResponseShuttingDownSchema = z.object({ outcome: z.literal(OzexportJobStartOutcomeEnum.SHUTTING_DOWN) });

package/schemas/parser/start-ozexport-job-s2s-response-started.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+
+export const StartOzexportJobS2SResponseStartedSchema = z.object({ outcome: z.literal(OzexportJobStartOutcomeEnum.STARTED) });

package/schemas/parser/start-ozexport-job-s2s-response.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { StartOzexportJobS2SResponseAlreadyRunningSchema } from './start-ozexport-job-s2s-response-already-running.schema';
+import { StartOzexportJobS2SResponseBusySchema } from './start-ozexport-job-s2s-response-busy.schema';
+import { StartOzexportJobS2SResponseFinishedSchema } from './start-ozexport-job-s2s-response-finished.schema';
+import { StartOzexportJobS2SResponsePausedSchema } from './start-ozexport-job-s2s-response-paused.schema';
+import { StartOzexportJobS2SResponseShuttingDownSchema } from './start-ozexport-job-s2s-response-shutting-down.schema';
+import { StartOzexportJobS2SResponseStartedSchema } from './start-ozexport-job-s2s-response-started.schema';
+
+// Все исходы start возвращаются с HTTP 200: HTTP-сбой означает недоступность, а не состояние задания.
+export const StartOzexportJobS2SResponseSchema = z.discriminatedUnion('outcome', [
+    StartOzexportJobS2SResponseStartedSchema,
+    StartOzexportJobS2SResponseAlreadyRunningSchema,
+    StartOzexportJobS2SResponseFinishedSchema,
+    StartOzexportJobS2SResponseBusySchema,
+    StartOzexportJobS2SResponsePausedSchema,
+    StartOzexportJobS2SResponseShuttingDownSchema,
+]);

package/schemas/positive-decimal4.schema.ts

@@ -0,0 +1,3 @@
+import { Decimal4Schema } from './decimal4.schema';
+
+export const PositiveDecimal4Schema = Decimal4Schema.refine(value => /[1-9]/.test(value), { message: 'Must be greater than zero' });

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-request.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { MatchingConfigSchema } from '../pre-order-product/matching-config.schema';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersRequestSchema = z.object({
+    standingOrderUUIDs: z.uuid().array(),
+    preOrderCollectionUUIDs: z.uuid().array(),
+    matchingConfig: MatchingConfigSchema.optional().nullable(),
+});

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response-data-analyses-mappings.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { PreOrderProductExtendedSchema } from '../pre-order-product/pre-order-product-extended.schema';
+import { CopyAnalysisMatchSchema } from './copy-analysis-match.schema';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesMappingsSchema = z.object({
+    standingOrderProduct: PreOrderProductExtendedSchema,
+    matches: z.array(CopyAnalysisMatchSchema),
+    remainingQuantity: z.number(),
+});

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response-data-analyses.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+import { AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesMappingsSchema } from './analyze-create-pre-orders-from-standing-orders-response-data-analyses-mappings.schema';
+import { PreOrderWithClientSchema } from './pre-order.schema';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesSchema = z.object({
+    standingOrder: PreOrderWithClientSchema,
+    mappings: z.record(z.string(), AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesMappingsSchema),
+    warnings: z.record(z.string(), z.array(ErrorMessageSchema)),
+});

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response-data-error-list.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersResponseDataErrorListSchema = z.object({
+    code: z.string(),
+    message: z.string(),
+});

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response-data.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesSchema } from './analyze-create-pre-orders-from-standing-orders-response-data-analyses.schema';
+import { AnalyzeCreatePreOrdersFromStandingOrdersResponseDataErrorListSchema } from './analyze-create-pre-orders-from-standing-orders-response-data-error-list.schema';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersResponseDataSchema = z.object({
+    analyses: z.array(AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesSchema),
+    errorList: z.array(AnalyzeCreatePreOrdersFromStandingOrdersResponseDataErrorListSchema).optional(),
+});

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { AnalyzeCreatePreOrdersFromStandingOrdersResponseDataSchema } from './analyze-create-pre-orders-from-standing-orders-response-data.schema';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersResponseSchema = z.object({
+    message: z.string().optional(),
+    data: AnalyzeCreatePreOrdersFromStandingOrdersResponseDataSchema,
+});

package/schemas/pre-order/copy-analysis-mapping.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { PreOrderProductExtendedSchema } from '../pre-order-product/pre-order-product-extended.schema';
+import { CopyAnalysisMatchSchema } from './copy-analysis-match.schema';
+
+export const CopyAnalysisMappingSchema = z.object({
+    sourceProduct: PreOrderProductExtendedSchema,
+    matches: z.array(CopyAnalysisMatchSchema),
+    remainingQuantity: z.number(),
+});

package/schemas/pre-order/copy-analysis-match.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemForAdminSchema } from '../pre-order-collection-item/pre-order-collection-item-for-admin.schema';
+
+export const CopyAnalysisMatchSchema = z.object({
+    collectionItem: PreOrderCollectionItemForAdminSchema,
+    quantity: z.number(),
+});

package/schemas/pre-order/copy-analysis.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+import { CopyAnalysisMappingSchema } from './copy-analysis-mapping.schema';
+import { PreOrderWithClientSchema } from './pre-order.schema';
+
+export const CopyAnalysisSchema = z.object({
+    preOrder: PreOrderWithClientSchema,
+    mappings: z.record(z.string(), CopyAnalysisMappingSchema),
+    warnings: z.record(z.string(), z.array(ErrorMessageSchema)),
+});

package/schemas/pre-order/get-pre-order-list-webshop-request.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { PreOrderStatusEnum } from '../../enum';
+
+export const GetPreOrderListWebshopRequestSchema = z.object({
+    page: z.coerce.number().optional().default(1),
+    count: z.coerce.number().optional().default(10),
+    statuses: z.array(z.nativeEnum(PreOrderStatusEnum)).optional(),
+});

package/schemas/pre-order/get-pre-order-list-webshop-response.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { PreOrderExtendedForClientListSchema } from './pre-order-extended-for-client-list.schema';
+
+export const GetPreOrderListWebshopResponseSchema = z.object({
+    data: PreOrderExtendedForClientListSchema,
+});

package/schemas/pre-order/get-pre-order-webshop-response.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { PreOrderExtendedForClientSchema } from './pre-order-extended-for-client.schema';
+
+export const GetPreOrderWebshopResponseSchema = z.object({
+    data: PreOrderExtendedForClientSchema,
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-request.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { MatchingConfigSchema } from '../pre-order-product/matching-config.schema';
+
+export const GroupCopyPreOrdersToCollectionRequestSchema = z.object({
+    preOrderUUIDList: z.array(z.uuid()),
+    targetPreOrderCollectionUUID: z.uuid(),
+    matchingConfig: MatchingConfigSchema.optional().nullable(),
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-response-data-created-target-pre-order.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const GroupCopyPreOrdersToCollectionResponseDataCreatedTargetPreOrderSchema = z.object({
+    uuid: z.string(),
+    preOrderNum: z.number(),
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-response-data-created.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+import { PreOrderCopySourceSchema } from './pre-order-copy-source.schema';
+import { GroupCopyPreOrdersToCollectionResponseDataCreatedTargetPreOrderSchema } from './group-copy-pre-orders-to-collection-response-data-created-target-pre-order.schema';
+
+export const GroupCopyPreOrdersToCollectionResponseDataCreatedSchema = z.object({
+    sourcePreOrder: PreOrderCopySourceSchema,
+    targetPreOrder: GroupCopyPreOrdersToCollectionResponseDataCreatedTargetPreOrderSchema,
+    warnings: z.array(ErrorMessageSchema),
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-response-data-failed.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+import { PreOrderCopySourceSchema } from './pre-order-copy-source.schema';
+
+export const GroupCopyPreOrdersToCollectionResponseDataFailedSchema = z.object({
+    sourcePreOrder: PreOrderCopySourceSchema,
+    error: z.array(ErrorMessageSchema),
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-response-data.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { GroupCopyPreOrdersToCollectionResponseDataCreatedSchema } from './group-copy-pre-orders-to-collection-response-data-created.schema';
+import { GroupCopyPreOrdersToCollectionResponseDataFailedSchema } from './group-copy-pre-orders-to-collection-response-data-failed.schema';
+
+export const GroupCopyPreOrdersToCollectionResponseDataSchema = z.object({
+    created: z.array(GroupCopyPreOrdersToCollectionResponseDataCreatedSchema),
+    failed: z.array(GroupCopyPreOrdersToCollectionResponseDataFailedSchema),
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { GroupCopyPreOrdersToCollectionResponseDataSchema } from './group-copy-pre-orders-to-collection-response-data.schema';
+
+export const GroupCopyPreOrdersToCollectionResponseSchema = z.object({
+    message: z.string().optional(),
+    data: GroupCopyPreOrdersToCollectionResponseDataSchema,
+});

package/schemas/pre-order/group-delete-pre-order-request.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const GroupDeletePreOrderRequestSchema = z.object({
+    uuids: z.array(z.string()).min(1),
+});

package/schemas/pre-order/group-delete-pre-order-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { DeleteDataResponseSchema } from '../delete-data-response.schema';
+
+export const GroupDeletePreOrderResponseSchema = z.object({
+    message: z.string().optional(),
+    data: DeleteDataResponseSchema,
+});

package/schemas/pre-order/group-update-pre-order-request.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { UpdatePreOrderSchema } from './pre-order.schema';
+
+export const GroupUpdatePreOrderRequestSchema = z.object({
+    uuids: z.array(z.string()).min(1),
+    data: UpdatePreOrderSchema,
+});

package/schemas/pre-order/group-update-pre-order-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { DeleteDataResponseSchema } from '../delete-data-response.schema';
+
+export const GroupUpdatePreOrderResponseSchema = z.object({
+    message: z.string().optional(),
+    data: DeleteDataResponseSchema,
+});

package/schemas/pre-order/index.ts

@@ -0,0 +1,27 @@
+export * from './analyze-create-pre-orders-from-standing-orders-request.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-response-data-analyses-mappings.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-response-data-analyses.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-response-data-error-list.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-response-data.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-response.schema';
+export * from './copy-analysis-mapping.schema';
+export * from './copy-analysis-match.schema';
+export * from './copy-analysis.schema';
+export * from './get-pre-order-list-webshop-request.schema';
+export * from './get-pre-order-list-webshop-response.schema';
+export * from './get-pre-order-webshop-response.schema';
+export * from './group-copy-pre-orders-to-collection-request.schema';
+export * from './group-copy-pre-orders-to-collection-response-data-created-target-pre-order.schema';
+export * from './group-copy-pre-orders-to-collection-response-data-created.schema';
+export * from './group-copy-pre-orders-to-collection-response-data-failed.schema';
+export * from './group-copy-pre-orders-to-collection-response-data.schema';
+export * from './group-copy-pre-orders-to-collection-response.schema';
+export * from './group-delete-pre-order-request.schema';
+export * from './group-delete-pre-order-response.schema';
+export * from './group-update-pre-order-request.schema';
+export * from './group-update-pre-order-response.schema';
+export * from './pre-order-extended-for-client-list.schema';
+export * from './pre-order-extended-for-client.schema';
+export * from './pre-order-for-client.schema';
+export * from './pre-order-summary.schema';
+export * from './pre-order.schema';

package/schemas/pre-order/pre-order-copy-source.schema.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const PreOrderCopySourceSchema = z.object({ uuid: z.string(), preOrderNum: z.number(), clientName: z.string() });

package/schemas/pre-order/pre-order-extended-for-client-list.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderExtendedForClientSchema } from './pre-order-extended-for-client.schema';
+
+export const PreOrderExtendedForClientListSchema = z.object({
+    list: z.array(PreOrderExtendedForClientSchema),
+    total: z.number(),
+});

package/schemas/pre-order/pre-order-extended-for-client.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { PreOrderForClientSchema } from './pre-order-for-client.schema';
+import { BranchSchema } from '../branch/branch.schema';
+import { PreOrderCollectionSchema } from '../pre-order-collection/pre-order-collection.schema';
+import { MoneySchema } from '../money.schema';
+
+export const PreOrderExtendedForClientSchema = PreOrderForClientSchema.extend({
+    branch: BranchSchema.nullable(),
+    preOrderCollection: PreOrderCollectionSchema.nullable(),
+    totalPositions: z.number(),
+    totalQuantity: z.number(),
+    totalPrice: MoneySchema,
+});

package/schemas/pre-order/pre-order-for-client.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { PreOrderStatusEnum } from '../../enum';
+
+export const PreOrderForClientSchema = z.object({
+    uuid: z.string(),
+    clientUUID: z.string(),
+    branchUUID: z.string().nullable(),
+    status: z.nativeEnum(PreOrderStatusEnum),
+    preOrderNum: z.number(),
+    comment: z.string().nullable(),
+    tag: z.string().nullable(),
+    createdAt: z.coerce.date(),
+});

package/schemas/pre-order/pre-order-summary.schema.ts

@@ -0,0 +1,3 @@
+import { PreOrderSchema } from './pre-order.schema';
+
+export const PreOrderSummarySchema = PreOrderSchema.pick({ uuid: true, preOrderNum: true, status: true, createdAt: true });

package/schemas/pre-order/pre-order.schema.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { PreOrderStatusEnum } from '../../enum';
-import { ClientSchema } from '../client';
+import { PreOrderStatusEnum } from '../../enum/pre-order-status.enum';
+import { ClientSchema } from '../client/client-base.schema';
 import { BranchSchema } from '../branch/branch.schema';
 import { PreOrderCollectionSchema } from '../pre-order-collection/pre-order-collection.schema';
 import { MoneySchema } from '../money.schema';

package/schemas/pre-order-collection/index.ts

@@ -0,0 +1,2 @@
+export * from './pre-order-collection.schema';
+export * from './pre-order-collection-summary-for-client.schema';

package/schemas/pre-order-collection/pre-order-collection-summary-for-client.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export const PreOrderCollectionSummaryForClientSchema = z.object({
+    uuid: z.string(),
+    description: z.string(),
+    availableUntil: z.date(),
+    deliveryDate: z.date(),
+});

package/schemas/pre-order-collection-item/create-pre-order-collection-item-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemForAdminSchema } from './pre-order-collection-item-for-admin.schema';
+
+export const CreatePreOrderCollectionItemResponseSchema = z.object({
+    message: z.string().optional(),
+    data: PreOrderCollectionItemForAdminSchema,
+});

package/schemas/pre-order-collection-item/create-pre-order-collection-item.schema.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { SalesUnitEnum } from '../../enum/sales-unit.enum';
+import { MoneySchema } from '../money.schema';
+
+export const CreatePreOrderCollectionItemSchema = z.object({
+    productUUID: z.string().optional(),
+    categoryUUID: z.string(),
+    isOpen: z.boolean().optional().default(false),
+    name: z.string(),
+    multiplicity: z.coerce.number(),
+    quantity: z.coerce.number().nullable().optional(),
+    balance: z.coerce.number().nullable().optional(),
+    imageUUID: z.string().nullable().optional(),
+    price: MoneySchema,
+    advancedPrice: z.string().nullable().optional(),
+    grower: z.string().nullable().optional(),
+    size: z.string().nullable().optional(),
+    isSizeCustomizable: z.boolean().optional().default(false),
+    size2: z.string().nullable().optional(),
+    size3: z.string().nullable().optional(),
+    color: z.string().nullable().optional(),
+    isColorCustomizable: z.boolean().optional().default(false),
+    country: z.string().optional(),
+    vat: z.coerce.number().nullable().optional(),
+    description: z.string().nullable().optional(),
+    article: z.string().nullable().optional(),
+    salesUnit: z.nativeEnum(SalesUnitEnum).optional(),
+    group: z.string().nullable().optional(),
+    multiplicityDescription: z.string().nullable().optional(),
+});

package/schemas/pre-order-collection-item/delete-group-pre-order-collection-item-request.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const DeleteGroupPreOrderCollectionItemRequestSchema = z.object({
+    preOrderCollectionItemUUIDs: z.array(z.string()),
+});

package/schemas/pre-order-collection-item/delete-group-pre-order-collection-item-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { DeleteGroupPreOrderCollectionItemResultSchema } from './delete-group-pre-order-collection-item-result.schema';
+
+export const DeleteGroupPreOrderCollectionItemResponseSchema = z.object({
+    message: z.string().optional(),
+    data: DeleteGroupPreOrderCollectionItemResultSchema,
+});

package/schemas/pre-order-collection-item/delete-group-pre-order-collection-item-result.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const DeleteGroupPreOrderCollectionItemResultSchema = z.object({
+    success: z.boolean(),
+    missedItems: z.array(z.string()).optional(),
+});

package/schemas/pre-order-collection-item/get-active-pre-order-collection-item-list-request.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const GetActivePreOrderCollectionItemListRequestSchema = z.object({
+    page: z.coerce.number().optional().default(1),
+    count: z.coerce.number().optional().default(10),
+    searchQuery: z.string().optional(),
+});

package/schemas/pre-order-collection-item/get-active-pre-order-collection-item-list-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemExtendedForAdminListSchema } from './pre-order-collection-item-extended-for-admin-list.schema';
+
+export const GetActivePreOrderCollectionItemListResponseSchema = z.object({
+    message: z.string().optional(),
+    data: PreOrderCollectionItemExtendedForAdminListSchema,
+});

package/schemas/pre-order-collection-item/get-pre-order-collection-item-grouped-list-for-client-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemCatalogGroupedForClientListSchema } from './pre-order-collection-item-catalog-grouped-for-client-list.schema';
+
+export const GetPreOrderCollectionItemGroupedListForClientResponseSchema = z.object({
+    message: z.string().optional(),
+    data: PreOrderCollectionItemCatalogGroupedForClientListSchema,
+});

package/schemas/pre-order-collection-item/get-pre-order-collection-item-list-for-client-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemCatalogForClientListSchema } from './pre-order-collection-item-catalog-for-client-list.schema';
+
+export const GetPreOrderCollectionItemListForClientResponseSchema = z.object({
+    message: z.string().optional(),
+    data: PreOrderCollectionItemCatalogForClientListSchema,
+});

package/schemas/pre-order-collection-item/get-pre-order-collection-item-list-request.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const GetPreOrderCollectionItemListRequestSchema = z.object({
+    page: z.coerce.number().optional().default(1),
+    count: z.coerce.number().optional().default(10),
+    sizes: z.array(z.string()).optional(),
+    colors: z.array(z.string()).optional(),
+    growers: z.array(z.string()).optional(),
+    countries: z.array(z.string()).optional(),
+    categoriesUUID: z.array(z.string()).optional(),
+    typesUUID: z.array(z.string()).optional(),
+    searchQuery: z.string().optional(),
+    hasPreOrder: z.coerce.boolean().optional(),
+});

package/schemas/pre-order-collection-item/get-pre-order-collection-item-list-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemExtendedForAdminListSchema } from './pre-order-collection-item-extended-for-admin-list.schema';
+
+export const GetPreOrderCollectionItemListResponseSchema = z.object({
+    message: z.string().optional(),
+    data: PreOrderCollectionItemExtendedForAdminListSchema,
+});

package/schemas/pre-order-collection-item/get-pre-order-collection-item-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemExtendedForAdminSchema } from './pre-order-collection-item-extended-for-admin.schema';
+
+export const GetPreOrderCollectionItemResponseSchema = z.object({
+    message: z.string().optional(),
+    data: PreOrderCollectionItemExtendedForAdminSchema,
+});

package/schemas/pre-order-collection-item/has-unique-supplier-add-keys.helper.ts

@@ -0,0 +1,3 @@
+// Один и тот же ключ предложения (productCode + stockType) не повторяется в одном запросе добавления.
+export const hasUniqueSupplierAddKeys = (items: Array<{ productCode: string; stockType: string }>): boolean =>
+    new Set(items.map(item => JSON.stringify([item.productCode, item.stockType]))).size === items.length;