@meerkapp/wms-contracts 0.3.0-beta.13 → 0.3.0-beta.15

package/dist/index.cjs

@@ -43,6 +43,7 @@ __export(index_exports, {
   CreateProductTypeSchema: () => CreateProductTypeSchema,
   CreateRoleSchema: () => CreateRoleSchema,
   CreateWarehouseSchema: () => CreateWarehouseSchema,
+  CurrencyCodeSchema: () => CurrencyCodeSchema,
   EmployeeRoleSchema: () => EmployeeRoleSchema,
   EmployeeSchema: () => EmployeeSchema,
   FolderSchema: () => FolderSchema,
@@ -50,32 +51,50 @@ __export(index_exports, {
   LoginSchema: () => LoginSchema,
   OrganizationSchema: () => OrganizationSchema,
   PaginationQuerySchema: () => PaginationQuerySchema,
+  PriceListAssignmentSchema: () => PriceListAssignmentSchema,
   PriceListSchema: () => PriceListSchema,
+  PriceListSummarySchema: () => PriceListSummarySchema,
   ProductBarcodeSchema: () => ProductBarcodeSchema,
   ProductBrandSchema: () => ProductBrandSchema,
   ProductCollectionSchema: () => ProductCollectionSchema,
   ProductItemSchema: () => ProductItemSchema,
+  ProductItemStatsChangePayloadSchema: () => ProductItemStatsChangePayloadSchema,
+  ProductItemStatsFetchQuerySchema: () => ProductItemStatsFetchQuerySchema,
+  ProductItemStatsFetchResponseSchema: () => ProductItemStatsFetchResponseSchema,
   ProductItemStatsQuerySchema: () => ProductItemStatsQuerySchema,
   ProductItemStatsSchema: () => ProductItemStatsSchema,
+  ProductItemStatsSocketPayloadSchema: () => ProductItemStatsSocketPayloadSchema,
   ProductItemWithRelationsSchema: () => ProductItemWithRelationsSchema,
   ProductMeasureSchema: () => ProductMeasureSchema,
   ProductPackageSchema: () => ProductPackageSchema,
+  ProductPriceInputSchema: () => ProductPriceInputSchema,
+  ProductPriceSchema: () => ProductPriceSchema,
   ProductShipmentSchema: () => ProductShipmentSchema,
   ProductTypeSchema: () => ProductTypeSchema,
   RolePermissionItemSchema: () => RolePermissionItemSchema,
   RoleSchema: () => RoleSchema,
+  SYNC_TABLE_NAMES: () => SYNC_TABLE_NAMES,
+  SetPriceListAssignmentsSchema: () => SetPriceListAssignmentsSchema,
   SetupInitSchema: () => SetupInitSchema,
+  SyncCursorSchema: () => SyncCursorSchema,
+  SyncEntityIdSchema: () => SyncEntityIdSchema,
+  SyncTableNameSchema: () => SyncTableNameSchema,
   UpdateEmployeeSchema: () => UpdateEmployeeSchema,
   UpdateFolderSchema: () => UpdateFolderSchema,
   UpdateOrganizationSchema: () => UpdateOrganizationSchema,
   UpdateOwnPasswordSchema: () => UpdateOwnPasswordSchema,
   UpdateOwnProfileSchema: () => UpdateOwnProfileSchema,
+  UpdatePriceListPricesSchema: () => UpdatePriceListPricesSchema,
   UpdatePriceListSchema: () => UpdatePriceListSchema,
   UpdateProductCollectionSchema: () => UpdateProductCollectionSchema,
   UpdateProductTypeSchema: () => UpdateProductTypeSchema,
   UpdateRoleSchema: () => UpdateRoleSchema,
   UpdateWarehouseSchema: () => UpdateWarehouseSchema,
-  WarehouseSchema: () => WarehouseSchema
+  WarehouseSchema: () => WarehouseSchema,
+  createSyncChangePayloadSchema: () => createSyncChangePayloadSchema,
+  createSyncFetchResponseSchema: () => createSyncFetchResponseSchema,
+  createSyncSocketPayloadSchema: () => createSyncSocketPayloadSchema,
+  getCurrencyMinorUnits: () => getCurrencyMinorUnits
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -86,6 +105,40 @@ var PaginationQuerySchema = import_zod.z.object({
   limit: import_zod.z.coerce.number().int().min(1).max(100).default(20)
 });
 
+// src/generated/schemas/enums/CurrencyCode.schema.ts
+var z2 = __toESM(require("zod"), 1);
+var CurrencyCodeSchema = z2.enum(["AED", "AFN", "ALL", "AMD", "ANG", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BMD", "BND", "BOB", "BRL", "BSD", "BTN", "BWP", "BYN", "BZD", "CAD", "CDF", "CHF", "CLP", "CNY", "COP", "CRC", "CUP", "CVE", "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL", "HTG", "HUF", "IDR", "ILS", "INR", "IQD", "IRR", "ISK", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRU", "MUR", "MVR", "MWK", "MXN", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SLE", "SOS", "SRD", "SSP", "STN", "SYP", "SZL", "THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "UZS", "VES", "VND", "VUV", "WST", "XAF", "XCD", "XOF", "XPF", "YER", "ZAR", "ZMW", "ZWL"]);
+
+// src/common/currency/index.ts
+var MINOR_UNIT_OVERRIDES = {
+  BHD: 3,
+  BIF: 0,
+  CLP: 0,
+  DJF: 0,
+  GNF: 0,
+  IQD: 3,
+  ISK: 0,
+  JOD: 3,
+  JPY: 0,
+  KMF: 0,
+  KRW: 0,
+  KWD: 3,
+  LYD: 3,
+  OMR: 3,
+  PYG: 0,
+  RWF: 0,
+  TND: 3,
+  UGX: 0,
+  VND: 0,
+  VUV: 0,
+  XAF: 0,
+  XOF: 0,
+  XPF: 0
+};
+function getCurrencyMinorUnits(currency) {
+  return MINOR_UNIT_OVERRIDES[currency] ?? 2;
+}
+
 // src/modules/auth/index.ts
 var import_zod2 = require("zod");
 var ALL_PERMISSIONS = [
@@ -143,14 +196,14 @@ var SetupInitSchema = import_zod2.z.object({
 var import_zod3 = require("zod");
 
 // src/generated/schemas/variants/pure/Organization.pure.ts
-var z3 = __toESM(require("zod"), 1);
-var OrganizationModelSchema = z3.object({
-  id: z3.number().int(),
-  name: z3.string(),
-  website: z3.string().nullable(),
-  updatedAt: z3.date(),
-  warehouses: z3.array(z3.unknown()),
-  priceListAssignments: z3.array(z3.unknown())
+var z4 = __toESM(require("zod"), 1);
+var OrganizationModelSchema = z4.object({
+  id: z4.number().int(),
+  name: z4.string(),
+  website: z4.string().nullable(),
+  updatedAt: z4.date(),
+  warehouses: z4.array(z4.unknown()),
+  priceListAssignments: z4.array(z4.unknown())
 }).strict();
 
 // src/modules/organization/index.ts
@@ -165,20 +218,21 @@ var OrganizationSchema = OrganizationModelSchema.omit({ warehouses: true }).exte
 var import_zod4 = require("zod");
 
 // src/generated/schemas/variants/pure/Warehouse.pure.ts
-var z5 = __toESM(require("zod"), 1);
-var WarehouseModelSchema = z5.object({
-  id: z5.number().int(),
-  address: z5.string(),
-  note: z5.string().nullable(),
-  code: z5.string(),
-  organizationId: z5.number().int(),
-  localityId: z5.number().int(),
-  updatedAt: z5.date(),
-  organization: z5.unknown(),
-  locality: z5.unknown(),
-  employees: z5.array(z5.unknown()),
-  shipments: z5.array(z5.unknown()),
-  priceListAssignments: z5.array(z5.unknown())
+var z6 = __toESM(require("zod"), 1);
+var WarehouseModelSchema = z6.object({
+  id: z6.number().int(),
+  address: z6.string(),
+  note: z6.string().nullable(),
+  code: z6.string(),
+  organizationId: z6.number().int(),
+  localityId: z6.number().int(),
+  updatedAt: z6.date(),
+  organization: z6.unknown(),
+  locality: z6.unknown(),
+  employees: z6.array(z6.unknown()),
+  shipments: z6.array(z6.unknown()),
+  priceListAssignments: z6.array(z6.unknown()),
+  stats: z6.array(z6.unknown())
 }).strict();
 
 // src/modules/warehouse/index.ts
@@ -196,15 +250,15 @@ var WarehouseSchema = WarehouseModelSchema.omit({ organization: true, locality:
 var import_zod5 = require("zod");
 
 // src/generated/schemas/variants/pure/Locality.pure.ts
-var z7 = __toESM(require("zod"), 1);
-var LocalityModelSchema = z7.object({
-  id: z7.number().int(),
-  name: z7.string(),
-  countryId: z7.number().int(),
-  updatedAt: z7.date(),
-  country: z7.unknown(),
-  warehouses: z7.array(z7.unknown()),
-  priceListAssignments: z7.array(z7.unknown())
+var z8 = __toESM(require("zod"), 1);
+var LocalityModelSchema = z8.object({
+  id: z8.number().int(),
+  name: z8.string(),
+  countryId: z8.number().int(),
+  updatedAt: z8.date(),
+  country: z8.unknown(),
+  warehouses: z8.array(z8.unknown()),
+  priceListAssignments: z8.array(z8.unknown())
 }).strict();
 
 // src/modules/locality/index.ts
@@ -218,14 +272,14 @@ var LocalitySchema = LocalityModelSchema.omit({ warehouses: true, country: true
 var import_zod6 = require("zod");
 
 // src/generated/schemas/variants/pure/Country.pure.ts
-var z9 = __toESM(require("zod"), 1);
-var CountryModelSchema = z9.object({
-  id: z9.number().int(),
-  code: z9.string(),
-  updatedAt: z9.date(),
-  localities: z9.array(z9.unknown()),
-  products: z9.array(z9.unknown()),
-  priceListAssignments: z9.array(z9.unknown())
+var z10 = __toESM(require("zod"), 1);
+var CountryModelSchema = z10.object({
+  id: z10.number().int(),
+  code: z10.string(),
+  updatedAt: z10.date(),
+  localities: z10.array(z10.unknown()),
+  products: z10.array(z10.unknown()),
+  priceListAssignments: z10.array(z10.unknown())
 }).strict();
 
 // src/modules/country/index.ts
@@ -235,32 +289,32 @@ var CountrySchema = CountryModelSchema.omit({ localities: true }).extend({ updat
 var import_zod7 = require("zod");
 
 // src/generated/schemas/variants/pure/Employee.pure.ts
-var z11 = __toESM(require("zod"), 1);
-var EmployeeModelSchema = z11.object({
-  id: z11.string(),
-  email: z11.string(),
-  password: z11.string(),
-  firstName: z11.string(),
-  lastName: z11.string(),
-  phone: z11.string().nullable(),
-  avatarUrl: z11.string().nullable(),
-  warehouseId: z11.number().int().nullable(),
-  isActive: z11.boolean(),
-  lastSeen: z11.date().nullable(),
-  updatedAt: z11.date(),
-  warehouse: z11.unknown().nullable(),
-  roleAssignments: z11.array(z11.unknown())
+var z12 = __toESM(require("zod"), 1);
+var EmployeeModelSchema = z12.object({
+  id: z12.string(),
+  email: z12.string(),
+  password: z12.string(),
+  firstName: z12.string(),
+  lastName: z12.string(),
+  phone: z12.string().nullable(),
+  avatarUrl: z12.string().nullable(),
+  warehouseId: z12.number().int().nullable(),
+  isActive: z12.boolean(),
+  lastSeen: z12.date().nullable(),
+  updatedAt: z12.date(),
+  warehouse: z12.unknown().nullable(),
+  roleAssignments: z12.array(z12.unknown())
 }).strict();
 
 // src/generated/schemas/variants/pure/EmployeeRole.pure.ts
-var z12 = __toESM(require("zod"), 1);
-var EmployeeRoleModelSchema = z12.object({
-  id: z12.number().int(),
-  name: z12.string(),
-  color: z12.string(),
-  updatedAt: z12.date(),
-  assignments: z12.array(z12.unknown()),
-  permissions: z12.array(z12.unknown())
+var z13 = __toESM(require("zod"), 1);
+var EmployeeRoleModelSchema = z13.object({
+  id: z13.number().int(),
+  name: z13.string(),
+  color: z13.string(),
+  updatedAt: z13.date(),
+  assignments: z13.array(z13.unknown()),
+  permissions: z13.array(z13.unknown())
 }).strict();
 
 // src/modules/employee/index.ts
@@ -457,13 +511,13 @@ var ProductCollectionSchema = import_zod11.z.object({
 var import_zod12 = require("zod");
 
 // src/generated/schemas/variants/pure/ProductMeasure.pure.ts
-var z18 = __toESM(require("zod"), 1);
-var ProductMeasureModelSchema = z18.object({
-  id: z18.number().int(),
-  name: z18.string().nullable(),
-  code: z18.string().nullable(),
-  updatedAt: z18.date(),
-  products: z18.array(z18.unknown())
+var z19 = __toESM(require("zod"), 1);
+var ProductMeasureModelSchema = z19.object({
+  id: z19.number().int(),
+  name: z19.string().nullable(),
+  code: z19.string().nullable(),
+  updatedAt: z19.date(),
+  products: z19.array(z19.unknown())
 }).strict();
 
 // src/modules/product-measure/index.ts
@@ -473,54 +527,104 @@ var ProductMeasureSchema = ProductMeasureModelSchema.omit({ products: true }).ex
 var import_zod13 = require("zod");
 
 // src/generated/schemas/variants/pure/ProductBrand.pure.ts
-var z20 = __toESM(require("zod"), 1);
-var ProductBrandModelSchema = z20.object({
-  id: z20.number().int(),
-  name: z20.string(),
-  updatedAt: z20.date(),
-  products: z20.array(z20.unknown())
+var z21 = __toESM(require("zod"), 1);
+var ProductBrandModelSchema = z21.object({
+  id: z21.number().int(),
+  name: z21.string(),
+  updatedAt: z21.date(),
+  products: z21.array(z21.unknown())
 }).strict();
 
 // src/modules/product-brand/index.ts
 var ProductBrandSchema = ProductBrandModelSchema.omit({ products: true }).extend({ updatedAt: import_zod13.z.string() });
 
 // src/modules/product-item/index.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // src/generated/schemas/variants/pure/ProductItem.pure.ts
-var z23 = __toESM(require("zod"), 1);
+var z24 = __toESM(require("zod"), 1);
 
 // src/generated/schemas/enums/WriteoffStrategy.schema.ts
-var z22 = __toESM(require("zod"), 1);
-var WriteoffStrategySchema = z22.enum(["FIFO", "LIFO", "FEFO", "MANUAL"]);
+var z23 = __toESM(require("zod"), 1);
+var WriteoffStrategySchema = z23.enum(["FIFO", "LIFO", "FEFO", "MANUAL"]);
 
 // src/generated/schemas/variants/pure/ProductItem.pure.ts
-var ProductItemModelSchema = z23.object({
-  id: z23.number().int(),
-  sku: z23.string(),
-  name: z23.string(),
-  productCollectionId: z23.number().int().nullable(),
-  productTypeId: z23.number().int(),
-  productBrandId: z23.number().int().nullable(),
-  productMeasureId: z23.number().int().nullable(),
-  countryId: z23.number().int().nullable(),
-  characteristics: z23.unknown(),
+var ProductItemModelSchema = z24.object({
+  id: z24.number().int(),
+  sku: z24.string(),
+  name: z24.string(),
+  productCollectionId: z24.number().int().nullable(),
+  productTypeId: z24.number().int(),
+  productBrandId: z24.number().int().nullable(),
+  productMeasureId: z24.number().int().nullable(),
+  countryId: z24.number().int().nullable(),
+  characteristics: z24.unknown(),
   writeoffStrategy: WriteoffStrategySchema.nullable(),
-  isPublic: z23.boolean(),
-  updatedAt: z23.date(),
-  productCollection: z23.unknown().nullable(),
-  productType: z23.unknown(),
-  productBrand: z23.unknown().nullable(),
-  productMeasure: z23.unknown().nullable(),
-  country: z23.unknown().nullable(),
-  barcodes: z23.array(z23.unknown()),
-  packages: z23.array(z23.unknown()),
-  shipments: z23.array(z23.unknown())
+  isPublic: z24.boolean(),
+  updatedAt: z24.date(),
+  productCollection: z24.unknown().nullable(),
+  productType: z24.unknown(),
+  productBrand: z24.unknown().nullable(),
+  productMeasure: z24.unknown().nullable(),
+  country: z24.unknown().nullable(),
+  barcodes: z24.array(z24.unknown()),
+  packages: z24.array(z24.unknown()),
+  shipments: z24.array(z24.unknown()),
+  stats: z24.array(z24.unknown())
 }).strict();
 
-// src/generated/schemas/enums/CurrencyCode.schema.ts
-var z24 = __toESM(require("zod"), 1);
-var CurrencyCodeSchema = z24.enum(["AED", "AFN", "ALL", "AMD", "ANG", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BMD", "BND", "BOB", "BRL", "BSD", "BTN", "BWP", "BYN", "BZD", "CAD", "CDF", "CHF", "CLP", "CNY", "COP", "CRC", "CUP", "CVE", "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL", "HTG", "HUF", "IDR", "ILS", "INR", "IQD", "IRR", "ISK", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRU", "MUR", "MVR", "MWK", "MXN", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SLE", "SOS", "SRD", "SSP", "STN", "SYP", "SZL", "THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "UZS", "VES", "VND", "VUV", "WST", "XAF", "XCD", "XOF", "XPF", "YER", "ZAR", "ZMW", "ZWL"]);
+// src/modules/sync/index.ts
+var import_zod14 = require("zod");
+var SYNC_TABLE_NAMES = [
+  "country",
+  "locality",
+  "organization",
+  "warehouse",
+  "folder",
+  "product_collection",
+  "product_type",
+  "product_brand",
+  "product_measure",
+  "product_package",
+  "product_shipment",
+  "product_item",
+  "product_barcode",
+  "product_item_stats"
+];
+var SyncTableNameSchema = import_zod14.z.enum(SYNC_TABLE_NAMES);
+var SyncCursorSchema = import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number(), import_zod14.z.null()]);
+var SyncEntityIdSchema = import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]);
+function createSyncFetchResponseSchema(itemSchema) {
+  return import_zod14.z.object({
+    items: import_zod14.z.array(itemSchema),
+    cursor: SyncCursorSchema,
+    hasMore: import_zod14.z.boolean()
+  });
+}
+function createSyncChangePayloadSchema(itemSchema) {
+  const ids = import_zod14.z.array(SyncEntityIdSchema);
+  return import_zod14.z.object({
+    added: import_zod14.z.array(itemSchema).optional(),
+    modified: import_zod14.z.array(itemSchema).optional(),
+    removed: ids.optional(),
+    upserted: import_zod14.z.array(itemSchema).optional(),
+    deletedIds: ids.optional(),
+    deleted: ids.optional(),
+    cursor: SyncCursorSchema.optional()
+  });
+}
+function createSyncSocketPayloadSchema(itemSchema) {
+  const ids = import_zod14.z.array(SyncEntityIdSchema);
+  return import_zod14.z.object({
+    added: import_zod14.z.array(itemSchema),
+    modified: import_zod14.z.array(itemSchema),
+    removed: ids,
+    upserted: import_zod14.z.array(itemSchema),
+    deletedIds: ids,
+    deleted: ids,
+    cursor: SyncCursorSchema
+  });
+}
 
 // src/modules/product-item/index.ts
 var ProductItemSchema = ProductItemModelSchema.omit({
@@ -532,118 +636,206 @@ var ProductItemSchema = ProductItemModelSchema.omit({
   barcodes: true,
   packages: true,
   shipments: true
-}).extend({ updatedAt: import_zod14.z.string() });
+}).extend({ updatedAt: import_zod15.z.string() });
 var ProductItemWithRelationsSchema = ProductItemSchema.extend({
   productBrand: ProductBrandSchema.nullable(),
   productMeasure: ProductMeasureSchema.nullable()
 });
-var ProductItemStatsQuerySchema = import_zod14.z.object({
-  productCollectionId: import_zod14.z.coerce.number().int().positive(),
-  warehouseId: import_zod14.z.coerce.number().int().positive()
-});
-var ProductItemStatsSchema = import_zod14.z.object({
-  id: import_zod14.z.number().int(),
-  productItemId: import_zod14.z.number().int(),
-  warehouseId: import_zod14.z.number().int(),
-  quantity: import_zod14.z.string(),
-  retailPrice: import_zod14.z.string().nullable(),
-  currency: CurrencyCodeSchema.nullable()
-});
+var ProductItemStatsQuerySchema = import_zod15.z.object({
+  productCollectionId: import_zod15.z.coerce.number().int().positive(),
+  warehouseId: import_zod15.z.coerce.number().int().positive()
+});
+var ProductItemStatsFetchQuerySchema = import_zod15.z.object({
+  warehouseId: import_zod15.z.coerce.number().int().positive(),
+  productCollectionId: import_zod15.z.coerce.number().int().positive().optional(),
+  cursor: import_zod15.z.string().min(1).optional(),
+  limit: import_zod15.z.coerce.number().int().positive().optional()
+});
+var ProductItemStatsSchema = import_zod15.z.object({
+  id: import_zod15.z.number().int(),
+  productItemId: import_zod15.z.number().int(),
+  warehouseId: import_zod15.z.number().int(),
+  quantity: import_zod15.z.string(),
+  retailPrice: import_zod15.z.string().nullable(),
+  currency: CurrencyCodeSchema.nullable(),
+  updatedAt: import_zod15.z.string()
+});
+var ProductItemStatsFetchResponseSchema = createSyncFetchResponseSchema(ProductItemStatsSchema);
+var ProductItemStatsChangePayloadSchema = createSyncChangePayloadSchema(ProductItemStatsSchema);
+var ProductItemStatsSocketPayloadSchema = createSyncSocketPayloadSchema(ProductItemStatsSchema);
 
 // src/modules/product-barcode/index.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // src/generated/schemas/variants/pure/ProductBarcode.pure.ts
-var z27 = __toESM(require("zod"), 1);
+var z28 = __toESM(require("zod"), 1);
 
 // src/generated/schemas/enums/BarcodeType.schema.ts
-var z26 = __toESM(require("zod"), 1);
-var BarcodeTypeSchema = z26.enum(["FACTORY", "CUSTOM"]);
+var z27 = __toESM(require("zod"), 1);
+var BarcodeTypeSchema = z27.enum(["FACTORY", "CUSTOM"]);
 
 // src/generated/schemas/variants/pure/ProductBarcode.pure.ts
-var ProductBarcodeModelSchema = z27.object({
-  id: z27.number().int(),
-  code: z27.string(),
+var ProductBarcodeModelSchema = z28.object({
+  id: z28.number().int(),
+  code: z28.string(),
   type: BarcodeTypeSchema,
-  productItemId: z27.number().int(),
-  updatedAt: z27.date(),
-  productItem: z27.unknown()
+  productItemId: z28.number().int(),
+  updatedAt: z28.date(),
+  productItem: z28.unknown()
 }).strict();
 
 // src/modules/product-barcode/index.ts
-var ProductBarcodeSchema = ProductBarcodeModelSchema.omit({ productItem: true }).extend({ updatedAt: import_zod15.z.string() });
+var ProductBarcodeSchema = ProductBarcodeModelSchema.omit({ productItem: true }).extend({ updatedAt: import_zod16.z.string() });
 
 // src/modules/product-package/index.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // src/generated/schemas/variants/pure/ProductPackage.pure.ts
-var z29 = __toESM(require("zod"), 1);
-var ProductPackageModelSchema = z29.object({
-  id: z29.number().int(),
-  name: z29.string().nullable(),
-  isBase: z29.boolean(),
-  productItemId: z29.number().int(),
-  conversionFactor: z29.number(),
-  updatedAt: z29.date(),
-  productItem: z29.unknown(),
-  prices: z29.array(z29.unknown())
+var z30 = __toESM(require("zod"), 1);
+var ProductPackageModelSchema = z30.object({
+  id: z30.number().int(),
+  name: z30.string().nullable(),
+  isBase: z30.boolean(),
+  productItemId: z30.number().int(),
+  conversionFactor: z30.number(),
+  updatedAt: z30.date(),
+  productItem: z30.unknown(),
+  prices: z30.array(z30.unknown())
 }).strict();
 
 // src/modules/product-package/index.ts
-var ProductPackageSchema = ProductPackageModelSchema.omit({ productItem: true }).extend({ updatedAt: import_zod16.z.string() });
+var ProductPackageSchema = ProductPackageModelSchema.omit({ productItem: true }).extend({ updatedAt: import_zod17.z.string() });
 
 // src/modules/product-shipment/index.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // src/generated/schemas/variants/pure/ProductShipment.pure.ts
-var z31 = __toESM(require("zod"), 1);
-var ProductShipmentModelSchema = z31.object({
-  id: z31.number().int(),
-  warehouseId: z31.number().int(),
-  productItemId: z31.number().int(),
-  arrivalDate: z31.date(),
-  expiryDate: z31.date().nullable(),
-  quantity: z31.number(),
-  priceAmount: z31.bigint(),
+var z32 = __toESM(require("zod"), 1);
+var ProductShipmentModelSchema = z32.object({
+  id: z32.number().int(),
+  warehouseId: z32.number().int(),
+  productItemId: z32.number().int(),
+  arrivalDate: z32.date(),
+  expiryDate: z32.date().nullable(),
+  quantity: z32.number(),
+  priceAmount: z32.bigint(),
   currency: CurrencyCodeSchema,
-  updatedAt: z31.date(),
-  warehouse: z31.unknown(),
-  productItem: z31.unknown()
+  updatedAt: z32.date(),
+  warehouse: z32.unknown(),
+  productItem: z32.unknown()
 }).strict();
 
 // src/modules/product-shipment/index.ts
 var ProductShipmentSchema = ProductShipmentModelSchema.omit({ warehouse: true, productItem: true }).extend({
-  arrivalDate: import_zod17.z.string(),
-  expiryDate: import_zod17.z.string().nullable(),
-  updatedAt: import_zod17.z.string()
+  arrivalDate: import_zod18.z.string(),
+  expiryDate: import_zod18.z.string().nullable(),
+  updatedAt: import_zod18.z.string()
 });
 
 // src/modules/price-list/index.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
+
+// src/generated/schemas/enums/PriceListTargetType.schema.ts
+var z34 = __toESM(require("zod"), 1);
+var PriceListTargetTypeSchema = z34.enum(["WAREHOUSE", "ORGANIZATION", "LOCALITY", "COUNTRY"]);
 
 // src/generated/schemas/variants/pure/PriceList.pure.ts
-var z33 = __toESM(require("zod"), 1);
-var PriceListModelSchema = z33.object({
-  id: z33.number().int(),
-  name: z33.string(),
+var z35 = __toESM(require("zod"), 1);
+var PriceListModelSchema = z35.object({
+  id: z35.number().int(),
+  name: z35.string(),
   currency: CurrencyCodeSchema,
-  isDefault: z33.boolean(),
-  createdAt: z33.date(),
-  updatedAt: z33.date(),
-  prices: z33.array(z33.unknown()),
-  assignments: z33.array(z33.unknown())
+  isDefault: z35.boolean(),
+  createdAt: z35.date(),
+  updatedAt: z35.date(),
+  prices: z35.array(z35.unknown()),
+  assignments: z35.array(z35.unknown())
 }).strict();
 
 // src/modules/price-list/index.ts
-var CreatePriceListSchema = import_zod18.z.object({
-  name: import_zod18.z.string().min(1),
+var CreatePriceListSchema = import_zod19.z.object({
+  name: import_zod19.z.string().min(1),
   currency: CurrencyCodeSchema
 });
 var UpdatePriceListSchema = CreatePriceListSchema.partial();
 var PriceListSchema = PriceListModelSchema.omit({
   prices: true,
   assignments: true
-}).extend({ updatedAt: import_zod18.z.string() });
+}).extend({
+  createdAt: import_zod19.z.string(),
+  updatedAt: import_zod19.z.string()
+});
+var PriceListSummarySchema = PriceListSchema.extend({
+  assignmentCount: import_zod19.z.number().int().nonnegative(),
+  priceCount: import_zod19.z.number().int().nonnegative()
+});
+var PriceListAssignmentSchema = import_zod19.z.object({
+  id: import_zod19.z.number().int().positive(),
+  priceListId: import_zod19.z.number().int().positive(),
+  targetType: PriceListTargetTypeSchema,
+  warehouseId: import_zod19.z.number().int().positive().nullable(),
+  organizationId: import_zod19.z.number().int().positive().nullable(),
+  localityId: import_zod19.z.number().int().positive().nullable(),
+  countryId: import_zod19.z.number().int().positive().nullable()
+});
+var IdArraySchema = import_zod19.z.array(import_zod19.z.number().int().positive());
+var SetPriceListAssignmentsSchema = import_zod19.z.object({
+  warehouseIds: IdArraySchema,
+  organizationIds: IdArraySchema,
+  localityIds: IdArraySchema,
+  countryIds: IdArraySchema
+}).superRefine((value, context) => {
+  for (const [field, ids] of Object.entries(value)) {
+    if (new Set(ids).size !== ids.length) {
+      context.addIssue({
+        code: import_zod19.z.ZodIssueCode.custom,
+        path: [field],
+        message: "Target ids must be unique"
+      });
+    }
+  }
+});
+var ProductPriceSchema = import_zod19.z.object({
+  id: import_zod19.z.number().int().positive(),
+  priceListId: import_zod19.z.number().int().positive(),
+  productPackageId: import_zod19.z.number().int().positive(),
+  priceAmount: import_zod19.z.string().regex(/^\d+$/),
+  createdAt: import_zod19.z.string(),
+  updatedAt: import_zod19.z.string()
+});
+var ProductPriceInputSchema = import_zod19.z.object({
+  productPackageId: import_zod19.z.number().int().positive(),
+  priceAmount: import_zod19.z.string().regex(/^\d+$/)
+});
+var UpdatePriceListPricesSchema = import_zod19.z.object({
+  upserted: import_zod19.z.array(ProductPriceInputSchema),
+  removedProductPackageIds: IdArraySchema
+}).superRefine((value, context) => {
+  const upsertedIds = value.upserted.map((price) => price.productPackageId);
+  if (new Set(upsertedIds).size !== upsertedIds.length) {
+    context.addIssue({
+      code: import_zod19.z.ZodIssueCode.custom,
+      path: ["upserted"],
+      message: "Product package ids must be unique"
+    });
+  }
+  const removedIds = value.removedProductPackageIds;
+  if (new Set(removedIds).size !== removedIds.length) {
+    context.addIssue({
+      code: import_zod19.z.ZodIssueCode.custom,
+      path: ["removedProductPackageIds"],
+      message: "Product package ids must be unique"
+    });
+  }
+  const removedIdSet = new Set(removedIds);
+  if (upsertedIds.some((id) => removedIdSet.has(id))) {
+    context.addIssue({
+      code: import_zod19.z.ZodIssueCode.custom,
+      path: ["removedProductPackageIds"],
+      message: "A product package cannot be updated and removed in the same request"
+    });
+  }
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALL_PERMISSIONS,
@@ -659,6 +851,7 @@ var PriceListSchema = PriceListModelSchema.omit({
   CreateProductTypeSchema,
   CreateRoleSchema,
   CreateWarehouseSchema,
+  CurrencyCodeSchema,
   EmployeeRoleSchema,
   EmployeeSchema,
   FolderSchema,
@@ -666,31 +859,49 @@ var PriceListSchema = PriceListModelSchema.omit({
   LoginSchema,
   OrganizationSchema,
   PaginationQuerySchema,
+  PriceListAssignmentSchema,
   PriceListSchema,
+  PriceListSummarySchema,
   ProductBarcodeSchema,
   ProductBrandSchema,
   ProductCollectionSchema,
   ProductItemSchema,
+  ProductItemStatsChangePayloadSchema,
+  ProductItemStatsFetchQuerySchema,
+  ProductItemStatsFetchResponseSchema,
   ProductItemStatsQuerySchema,
   ProductItemStatsSchema,
+  ProductItemStatsSocketPayloadSchema,
   ProductItemWithRelationsSchema,
   ProductMeasureSchema,
   ProductPackageSchema,
+  ProductPriceInputSchema,
+  ProductPriceSchema,
   ProductShipmentSchema,
   ProductTypeSchema,
   RolePermissionItemSchema,
   RoleSchema,
+  SYNC_TABLE_NAMES,
+  SetPriceListAssignmentsSchema,
   SetupInitSchema,
+  SyncCursorSchema,
+  SyncEntityIdSchema,
+  SyncTableNameSchema,
   UpdateEmployeeSchema,
   UpdateFolderSchema,
   UpdateOrganizationSchema,
   UpdateOwnPasswordSchema,
   UpdateOwnProfileSchema,
+  UpdatePriceListPricesSchema,
   UpdatePriceListSchema,
   UpdateProductCollectionSchema,
   UpdateProductTypeSchema,
   UpdateRoleSchema,
   UpdateWarehouseSchema,
-  WarehouseSchema
+  WarehouseSchema,
+  createSyncChangePayloadSchema,
+  createSyncFetchResponseSchema,
+  createSyncSocketPayloadSchema,
+  getCurrencyMinorUnits
 });
 //# sourceMappingURL=index.cjs.map