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

package/dist/index.js

@@ -5,8 +5,42 @@ var PaginationQuerySchema = z.object({
   limit: z.coerce.number().int().min(1).max(100).default(20)
 });
 
+// src/generated/schemas/enums/CurrencyCode.schema.ts
+import * as z2 from "zod";
+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
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var ALL_PERMISSIONS = [
   "organization:create",
   "organization:update",
@@ -47,254 +81,255 @@ var ALL_PERMISSIONS = [
   "price_list:create",
   "price_list:update"
 ];
-var LoginSchema = z2.object({
-  email: z2.string().email(),
-  password: z2.string().min(1)
+var LoginSchema = z3.object({
+  email: z3.string().email(),
+  password: z3.string().min(1)
 });
-var SetupInitSchema = z2.object({
-  email: z2.string().email(),
-  password: z2.string().min(8),
-  firstName: z2.string().min(1),
-  lastName: z2.string().min(1)
+var SetupInitSchema = z3.object({
+  email: z3.string().email(),
+  password: z3.string().min(8),
+  firstName: z3.string().min(1),
+  lastName: z3.string().min(1)
 });
 
 // src/modules/organization/index.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/generated/schemas/variants/pure/Organization.pure.ts
-import * as z3 from "zod";
-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())
+import * as z4 from "zod";
+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
-var CreateOrganizationSchema = z4.object({
-  name: z4.string().min(1),
-  website: z4.string().url().optional().nullable()
+var CreateOrganizationSchema = z5.object({
+  name: z5.string().min(1),
+  website: z5.string().url().optional().nullable()
 });
 var UpdateOrganizationSchema = CreateOrganizationSchema.partial();
-var OrganizationSchema = OrganizationModelSchema.omit({ warehouses: true }).extend({ updatedAt: z4.string() });
+var OrganizationSchema = OrganizationModelSchema.omit({ warehouses: true }).extend({ updatedAt: z5.string() });
 
 // src/modules/warehouse/index.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/generated/schemas/variants/pure/Warehouse.pure.ts
-import * as z5 from "zod";
-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())
+import * as z6 from "zod";
+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
-var CreateWarehouseSchema = z6.object({
-  address: z6.string().min(1),
-  note: z6.string().optional().nullable(),
-  code: z6.string().min(1),
-  organizationId: z6.number().int().positive(),
-  localityId: z6.number().int().positive()
+var CreateWarehouseSchema = z7.object({
+  address: z7.string().min(1),
+  note: z7.string().optional().nullable(),
+  code: z7.string().min(1),
+  organizationId: z7.number().int().positive(),
+  localityId: z7.number().int().positive()
 });
 var UpdateWarehouseSchema = CreateWarehouseSchema.partial();
-var WarehouseSchema = WarehouseModelSchema.omit({ organization: true, locality: true }).extend({ updatedAt: z6.string() });
+var WarehouseSchema = WarehouseModelSchema.omit({ organization: true, locality: true }).extend({ updatedAt: z7.string() });
 
 // src/modules/locality/index.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/generated/schemas/variants/pure/Locality.pure.ts
-import * as z7 from "zod";
-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())
+import * as z8 from "zod";
+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
-var CreateLocalitySchema = z8.object({
-  name: z8.string().min(1),
-  countryId: z8.number().int().positive()
+var CreateLocalitySchema = z9.object({
+  name: z9.string().min(1),
+  countryId: z9.number().int().positive()
 });
-var LocalitySchema = LocalityModelSchema.omit({ warehouses: true, country: true }).extend({ updatedAt: z8.string() });
+var LocalitySchema = LocalityModelSchema.omit({ warehouses: true, country: true }).extend({ updatedAt: z9.string() });
 
 // src/modules/country/index.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/generated/schemas/variants/pure/Country.pure.ts
-import * as z9 from "zod";
-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())
+import * as z10 from "zod";
+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
-var CountrySchema = CountryModelSchema.omit({ localities: true }).extend({ updatedAt: z10.string() });
+var CountrySchema = CountryModelSchema.omit({ localities: true }).extend({ updatedAt: z11.string() });
 
 // src/modules/employee/index.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/generated/schemas/variants/pure/Employee.pure.ts
-import * as z11 from "zod";
-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())
+import * as z12 from "zod";
+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
-import * as z12 from "zod";
-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())
+import * as z13 from "zod";
+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
-var EmployeeRoleSchema = EmployeeRoleModelSchema.omit({ assignments: true, permissions: true }).extend({ id: z13.number(), updatedAt: z13.string() });
+var EmployeeRoleSchema = EmployeeRoleModelSchema.omit({ assignments: true, permissions: true }).extend({ id: z14.number(), updatedAt: z14.string() });
 var EmployeeSchema = EmployeeModelSchema.omit({ password: true, warehouse: true, roleAssignments: true }).extend({
-  avatarUrl: z13.string().nullable(),
-  phone: z13.string().nullable(),
-  lastSeen: z13.string().nullable(),
-  updatedAt: z13.string(),
-  roleAssignments: z13.array(
-    z13.object({
+  avatarUrl: z14.string().nullable(),
+  phone: z14.string().nullable(),
+  lastSeen: z14.string().nullable(),
+  updatedAt: z14.string(),
+  roleAssignments: z14.array(
+    z14.object({
       employeeRole: EmployeeRoleSchema
     })
   )
 });
-var CreateEmployeeSchema = z13.object({
-  email: z13.string().email(),
-  password: z13.string().min(8),
-  firstName: z13.string().min(1),
-  lastName: z13.string().min(1),
-  phone: z13.string().min(7).max(20).optional(),
-  warehouseId: z13.number().int().optional(),
-  roleIds: z13.array(z13.number().int()).optional()
-});
-var UpdateEmployeeSchema = z13.object({
-  firstName: z13.string().min(1).optional(),
-  lastName: z13.string().min(1).optional(),
-  phone: z13.string().min(7).max(20).nullable().optional(),
-  warehouseId: z13.number().int().nullable().optional(),
-  roleIds: z13.array(z13.number().int()).optional(),
-  email: z13.string().email().optional(),
-  newPassword: z13.string().min(8).optional(),
-  isActive: z13.boolean().optional()
-});
-var UpdateOwnProfileSchema = z13.object({
-  firstName: z13.string().min(1).optional(),
-  lastName: z13.string().min(1).optional(),
-  phone: z13.string().min(7).max(20).nullable().optional(),
-  email: z13.string().email().optional()
-});
-var UpdateOwnPasswordSchema = z13.object({
-  currentPassword: z13.string().min(1),
-  newPassword: z13.string().min(8)
+var CreateEmployeeSchema = z14.object({
+  email: z14.string().email(),
+  password: z14.string().min(8),
+  firstName: z14.string().min(1),
+  lastName: z14.string().min(1),
+  phone: z14.string().min(7).max(20).optional(),
+  warehouseId: z14.number().int().optional(),
+  roleIds: z14.array(z14.number().int()).optional()
+});
+var UpdateEmployeeSchema = z14.object({
+  firstName: z14.string().min(1).optional(),
+  lastName: z14.string().min(1).optional(),
+  phone: z14.string().min(7).max(20).nullable().optional(),
+  warehouseId: z14.number().int().nullable().optional(),
+  roleIds: z14.array(z14.number().int()).optional(),
+  email: z14.string().email().optional(),
+  newPassword: z14.string().min(8).optional(),
+  isActive: z14.boolean().optional()
+});
+var UpdateOwnProfileSchema = z14.object({
+  firstName: z14.string().min(1).optional(),
+  lastName: z14.string().min(1).optional(),
+  phone: z14.string().min(7).max(20).nullable().optional(),
+  email: z14.string().email().optional()
+});
+var UpdateOwnPasswordSchema = z14.object({
+  currentPassword: z14.string().min(1),
+  newPassword: z14.string().min(8)
 });
 
 // src/modules/role/index.ts
-import { z as z14 } from "zod";
-var RolePermissionItemSchema = z14.object({
-  employeePermission: z14.object({
-    id: z14.number(),
-    name: z14.string()
+import { z as z15 } from "zod";
+var RolePermissionItemSchema = z15.object({
+  employeePermission: z15.object({
+    id: z15.number(),
+    name: z15.string()
   })
 });
 var RoleSchema = EmployeeRoleModelSchema.omit({ assignments: true, permissions: true }).extend({
-  id: z14.number(),
-  updatedAt: z14.string(),
-  permissions: z14.array(RolePermissionItemSchema)
+  id: z15.number(),
+  updatedAt: z15.string(),
+  permissions: z15.array(RolePermissionItemSchema)
 });
-var CreateRoleSchema = z14.object({
-  name: z14.string().min(1),
-  color: z14.string(),
-  permissionIds: z14.array(z14.number().int()).optional()
+var CreateRoleSchema = z15.object({
+  name: z15.string().min(1),
+  color: z15.string(),
+  permissionIds: z15.array(z15.number().int()).optional()
 });
-var UpdateRoleSchema = z14.object({
-  name: z14.string().min(1).optional(),
-  color: z14.string().optional(),
-  permissionIds: z14.array(z14.number().int()).optional()
+var UpdateRoleSchema = z15.object({
+  name: z15.string().min(1).optional(),
+  color: z15.string().optional(),
+  permissionIds: z15.array(z15.number().int()).optional()
 });
 
 // src/modules/product-type/index.ts
-import { z as z15 } from "zod";
-var NumberCharacteristicSchema = z15.object({
-  key: z15.string().min(1),
-  label: z15.string().min(1),
-  type: z15.literal("number"),
-  required: z15.boolean().default(false),
-  validation: z15.object({
-    min: z15.number().optional(),
-    max: z15.number().optional()
+import { z as z16 } from "zod";
+var NumberCharacteristicSchema = z16.object({
+  key: z16.string().min(1),
+  label: z16.string().min(1),
+  type: z16.literal("number"),
+  required: z16.boolean().default(false),
+  validation: z16.object({
+    min: z16.number().optional(),
+    max: z16.number().optional()
   }).optional(),
-  ui: z15.object({
-    suffix: z15.string().optional()
+  ui: z16.object({
+    suffix: z16.string().optional()
   }).optional()
 });
-var SelectOptionSchema = z15.object({
-  label: z15.string().min(1),
-  value: z15.string().min(1)
-});
-var SelectCharacteristicSchema = z15.object({
-  key: z15.string().min(1),
-  label: z15.string().min(1),
-  type: z15.literal("select"),
-  required: z15.boolean().default(false),
-  options: z15.array(SelectOptionSchema).min(1)
-});
-var ToggleCharacteristicSchema = z15.object({
-  key: z15.string().min(1),
-  label: z15.string().min(1),
-  type: z15.literal("toggle"),
-  required: z15.boolean().default(false),
-  true_label: z15.string().min(1),
-  false_label: z15.string().min(1)
-});
-var CheckboxCharacteristicSchema = z15.object({
-  key: z15.string().min(1),
-  label: z15.string().min(1),
-  type: z15.literal("checkbox")
-});
-var CharacteristicSchema = z15.discriminatedUnion("type", [
+var SelectOptionSchema = z16.object({
+  label: z16.string().min(1),
+  value: z16.string().min(1)
+});
+var SelectCharacteristicSchema = z16.object({
+  key: z16.string().min(1),
+  label: z16.string().min(1),
+  type: z16.literal("select"),
+  required: z16.boolean().default(false),
+  options: z16.array(SelectOptionSchema).min(1)
+});
+var ToggleCharacteristicSchema = z16.object({
+  key: z16.string().min(1),
+  label: z16.string().min(1),
+  type: z16.literal("toggle"),
+  required: z16.boolean().default(false),
+  true_label: z16.string().min(1),
+  false_label: z16.string().min(1)
+});
+var CheckboxCharacteristicSchema = z16.object({
+  key: z16.string().min(1),
+  label: z16.string().min(1),
+  type: z16.literal("checkbox")
+});
+var CharacteristicSchema = z16.discriminatedUnion("type", [
   NumberCharacteristicSchema,
   SelectCharacteristicSchema,
   ToggleCharacteristicSchema,
   CheckboxCharacteristicSchema
 ]);
-var CharacteristicsSchemeSchema = z15.array(CharacteristicSchema);
+var CharacteristicsSchemeSchema = z16.array(CharacteristicSchema);
 var SKU_TEMPLATE_REGEX = /^(\{(brand|counter)(?::\d+)?\}|\{[a-z_]+(?::\d+)?\}|[^{}]+)+$/;
 var RESERVED_SKU_KEYS = /* @__PURE__ */ new Set(["brand", "counter"]);
 var SKU_COMPATIBLE_TYPES = /* @__PURE__ */ new Set(["number", "select", "toggle"]);
@@ -306,11 +341,11 @@ function validateSkuTemplate(data) {
   const templateKeys = [...data.skuTemplate.matchAll(/\{([a-z_]+)(?::\d+)?\}/g)].map(([, key]) => key).filter((key) => !RESERVED_SKU_KEYS.has(key));
   return templateKeys.every((key) => skuCompatibleKeys.has(key));
 }
-var ProductTypeBaseSchema = z15.object({
-  name: z15.string().min(1),
-  defaultWriteoffStrategy: z15.enum(["FIFO", "LIFO", "FEFO", "MANUAL"]).default("FIFO"),
-  skuMode: z15.enum(["GLOBAL", "CUSTOM"]).default("GLOBAL"),
-  skuTemplate: z15.string().regex(SKU_TEMPLATE_REGEX, "Invalid SKU template format").optional().nullable(),
+var ProductTypeBaseSchema = z16.object({
+  name: z16.string().min(1),
+  defaultWriteoffStrategy: z16.enum(["FIFO", "LIFO", "FEFO", "MANUAL"]).default("FIFO"),
+  skuMode: z16.enum(["GLOBAL", "CUSTOM"]).default("GLOBAL"),
+  skuTemplate: z16.string().regex(SKU_TEMPLATE_REGEX, "Invalid SKU template format").optional().nullable(),
   characteristicsScheme: CharacteristicsSchemeSchema.optional().nullable()
 });
 var CreateProductTypeSchema = ProductTypeBaseSchema.refine(
@@ -327,119 +362,169 @@ var UpdateProductTypeSchema = ProductTypeBaseSchema.partial().refine(
   message: "All keys in skuTemplate must be required characteristics of type number, select or toggle",
   path: ["skuTemplate"]
 });
-var ProductTypeSchema = z15.object({
-  id: z15.number(),
-  name: z15.string(),
-  defaultWriteoffStrategy: z15.enum(["FIFO", "LIFO", "FEFO", "MANUAL"]),
-  skuMode: z15.enum(["GLOBAL", "CUSTOM"]),
-  skuTemplate: z15.string().nullable(),
-  skuCounter: z15.number(),
-  characteristicsScheme: CharacteristicsSchemeSchema.nullable(),
-  updatedAt: z15.string()
-});
-
-// src/modules/folder/index.ts
-import { z as z16 } from "zod";
-var CreateFolderSchema = z16.object({
-  name: z16.string().min(1),
-  parentId: z16.number().int().positive().optional().nullable()
-});
-var UpdateFolderSchema = CreateFolderSchema.partial();
-var FolderSchema = z16.object({
+var ProductTypeSchema = z16.object({
   id: z16.number(),
   name: z16.string(),
-  parentId: z16.number().nullable(),
-  pinnedAt: z16.string().nullable(),
-  pinOrder: z16.number().nullable(),
+  defaultWriteoffStrategy: z16.enum(["FIFO", "LIFO", "FEFO", "MANUAL"]),
+  skuMode: z16.enum(["GLOBAL", "CUSTOM"]),
+  skuTemplate: z16.string().nullable(),
+  skuCounter: z16.number(),
+  characteristicsScheme: CharacteristicsSchemeSchema.nullable(),
   updatedAt: z16.string()
 });
 
-// src/modules/product-collection/index.ts
+// src/modules/folder/index.ts
 import { z as z17 } from "zod";
-var CreateProductCollectionSchema = z17.object({
+var CreateFolderSchema = z17.object({
   name: z17.string().min(1),
-  folderId: z17.number().int().positive().optional().nullable(),
-  defaultProductTypeId: z17.number().int().positive().optional().nullable()
+  parentId: z17.number().int().positive().optional().nullable()
 });
-var UpdateProductCollectionSchema = CreateProductCollectionSchema.partial();
-var ProductCollectionSchema = z17.object({
+var UpdateFolderSchema = CreateFolderSchema.partial();
+var FolderSchema = z17.object({
   id: z17.number(),
   name: z17.string(),
-  folderId: z17.number().nullable(),
-  defaultProductTypeId: z17.number().nullable(),
+  parentId: z17.number().nullable(),
   pinnedAt: z17.string().nullable(),
   pinOrder: z17.number().nullable(),
   updatedAt: z17.string()
 });
 
+// src/modules/product-collection/index.ts
+import { z as z18 } from "zod";
+var CreateProductCollectionSchema = z18.object({
+  name: z18.string().min(1),
+  folderId: z18.number().int().positive().optional().nullable(),
+  defaultProductTypeId: z18.number().int().positive().optional().nullable()
+});
+var UpdateProductCollectionSchema = CreateProductCollectionSchema.partial();
+var ProductCollectionSchema = z18.object({
+  id: z18.number(),
+  name: z18.string(),
+  folderId: z18.number().nullable(),
+  defaultProductTypeId: z18.number().nullable(),
+  pinnedAt: z18.string().nullable(),
+  pinOrder: z18.number().nullable(),
+  updatedAt: z18.string()
+});
+
 // src/modules/product-measure/index.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/generated/schemas/variants/pure/ProductMeasure.pure.ts
-import * as z18 from "zod";
-var ProductMeasureModelSchema = z18.object({
-  id: z18.number().int(),
-  name: z18.string().nullable(),
-  code: z18.string().nullable(),
-  updatedAt: z18.date(),
-  products: z18.array(z18.unknown())
+import * as z19 from "zod";
+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
-var ProductMeasureSchema = ProductMeasureModelSchema.omit({ products: true }).extend({ updatedAt: z19.string() });
+var ProductMeasureSchema = ProductMeasureModelSchema.omit({ products: true }).extend({ updatedAt: z20.string() });
 
 // src/modules/product-brand/index.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // src/generated/schemas/variants/pure/ProductBrand.pure.ts
-import * as z20 from "zod";
-var ProductBrandModelSchema = z20.object({
-  id: z20.number().int(),
-  name: z20.string(),
-  updatedAt: z20.date(),
-  products: z20.array(z20.unknown())
+import * as z21 from "zod";
+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: z21.string() });
+var ProductBrandSchema = ProductBrandModelSchema.omit({ products: true }).extend({ updatedAt: z22.string() });
 
 // src/modules/product-item/index.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // src/generated/schemas/variants/pure/ProductItem.pure.ts
-import * as z23 from "zod";
+import * as z24 from "zod";
 
 // src/generated/schemas/enums/WriteoffStrategy.schema.ts
-import * as z22 from "zod";
-var WriteoffStrategySchema = z22.enum(["FIFO", "LIFO", "FEFO", "MANUAL"]);
+import * as z23 from "zod";
+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
-import * as z24 from "zod";
-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
+import { z as z25 } from "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 = z25.enum(SYNC_TABLE_NAMES);
+var SyncCursorSchema = z25.union([z25.string(), z25.number(), z25.null()]);
+var SyncEntityIdSchema = z25.union([z25.string(), z25.number()]);
+function createSyncFetchResponseSchema(itemSchema) {
+  return z25.object({
+    items: z25.array(itemSchema),
+    cursor: SyncCursorSchema,
+    hasMore: z25.boolean()
+  });
+}
+function createSyncChangePayloadSchema(itemSchema) {
+  const ids = z25.array(SyncEntityIdSchema);
+  return z25.object({
+    added: z25.array(itemSchema).optional(),
+    modified: z25.array(itemSchema).optional(),
+    removed: ids.optional(),
+    upserted: z25.array(itemSchema).optional(),
+    deletedIds: ids.optional(),
+    deleted: ids.optional(),
+    cursor: SyncCursorSchema.optional()
+  });
+}
+function createSyncSocketPayloadSchema(itemSchema) {
+  const ids = z25.array(SyncEntityIdSchema);
+  return z25.object({
+    added: z25.array(itemSchema),
+    modified: z25.array(itemSchema),
+    removed: ids,
+    upserted: z25.array(itemSchema),
+    deletedIds: ids,
+    deleted: ids,
+    cursor: SyncCursorSchema
+  });
+}
 
 // src/modules/product-item/index.ts
 var ProductItemSchema = ProductItemModelSchema.omit({
@@ -451,118 +536,206 @@ var ProductItemSchema = ProductItemModelSchema.omit({
   barcodes: true,
   packages: true,
   shipments: true
-}).extend({ updatedAt: z25.string() });
+}).extend({ updatedAt: z26.string() });
 var ProductItemWithRelationsSchema = ProductItemSchema.extend({
   productBrand: ProductBrandSchema.nullable(),
   productMeasure: ProductMeasureSchema.nullable()
 });
-var ProductItemStatsQuerySchema = z25.object({
-  productCollectionId: z25.coerce.number().int().positive(),
-  warehouseId: z25.coerce.number().int().positive()
-});
-var ProductItemStatsSchema = z25.object({
-  id: z25.number().int(),
-  productItemId: z25.number().int(),
-  warehouseId: z25.number().int(),
-  quantity: z25.string(),
-  retailPrice: z25.string().nullable(),
-  currency: CurrencyCodeSchema.nullable()
-});
+var ProductItemStatsQuerySchema = z26.object({
+  productCollectionId: z26.coerce.number().int().positive(),
+  warehouseId: z26.coerce.number().int().positive()
+});
+var ProductItemStatsFetchQuerySchema = z26.object({
+  warehouseId: z26.coerce.number().int().positive(),
+  productCollectionId: z26.coerce.number().int().positive().optional(),
+  cursor: z26.string().min(1).optional(),
+  limit: z26.coerce.number().int().positive().optional()
+});
+var ProductItemStatsSchema = z26.object({
+  id: z26.number().int(),
+  productItemId: z26.number().int(),
+  warehouseId: z26.number().int(),
+  quantity: z26.string(),
+  retailPrice: z26.string().nullable(),
+  currency: CurrencyCodeSchema.nullable(),
+  updatedAt: z26.string()
+});
+var ProductItemStatsFetchResponseSchema = createSyncFetchResponseSchema(ProductItemStatsSchema);
+var ProductItemStatsChangePayloadSchema = createSyncChangePayloadSchema(ProductItemStatsSchema);
+var ProductItemStatsSocketPayloadSchema = createSyncSocketPayloadSchema(ProductItemStatsSchema);
 
 // src/modules/product-barcode/index.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 
 // src/generated/schemas/variants/pure/ProductBarcode.pure.ts
-import * as z27 from "zod";
+import * as z28 from "zod";
 
 // src/generated/schemas/enums/BarcodeType.schema.ts
-import * as z26 from "zod";
-var BarcodeTypeSchema = z26.enum(["FACTORY", "CUSTOM"]);
+import * as z27 from "zod";
+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: z28.string() });
+var ProductBarcodeSchema = ProductBarcodeModelSchema.omit({ productItem: true }).extend({ updatedAt: z29.string() });
 
 // src/modules/product-package/index.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 
 // src/generated/schemas/variants/pure/ProductPackage.pure.ts
-import * as z29 from "zod";
-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())
+import * as z30 from "zod";
+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: z30.string() });
+var ProductPackageSchema = ProductPackageModelSchema.omit({ productItem: true }).extend({ updatedAt: z31.string() });
 
 // src/modules/product-shipment/index.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // src/generated/schemas/variants/pure/ProductShipment.pure.ts
-import * as z31 from "zod";
-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(),
+import * as z32 from "zod";
+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: z32.string(),
-  expiryDate: z32.string().nullable(),
-  updatedAt: z32.string()
+  arrivalDate: z33.string(),
+  expiryDate: z33.string().nullable(),
+  updatedAt: z33.string()
 });
 
 // src/modules/price-list/index.ts
-import { z as z34 } from "zod";
+import { z as z36 } from "zod";
+
+// src/generated/schemas/enums/PriceListTargetType.schema.ts
+import * as z34 from "zod";
+var PriceListTargetTypeSchema = z34.enum(["WAREHOUSE", "ORGANIZATION", "LOCALITY", "COUNTRY"]);
 
 // src/generated/schemas/variants/pure/PriceList.pure.ts
-import * as z33 from "zod";
-var PriceListModelSchema = z33.object({
-  id: z33.number().int(),
-  name: z33.string(),
+import * as z35 from "zod";
+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 = z34.object({
-  name: z34.string().min(1),
+var CreatePriceListSchema = z36.object({
+  name: z36.string().min(1),
   currency: CurrencyCodeSchema
 });
 var UpdatePriceListSchema = CreatePriceListSchema.partial();
 var PriceListSchema = PriceListModelSchema.omit({
   prices: true,
   assignments: true
-}).extend({ updatedAt: z34.string() });
+}).extend({
+  createdAt: z36.string(),
+  updatedAt: z36.string()
+});
+var PriceListSummarySchema = PriceListSchema.extend({
+  assignmentCount: z36.number().int().nonnegative(),
+  priceCount: z36.number().int().nonnegative()
+});
+var PriceListAssignmentSchema = z36.object({
+  id: z36.number().int().positive(),
+  priceListId: z36.number().int().positive(),
+  targetType: PriceListTargetTypeSchema,
+  warehouseId: z36.number().int().positive().nullable(),
+  organizationId: z36.number().int().positive().nullable(),
+  localityId: z36.number().int().positive().nullable(),
+  countryId: z36.number().int().positive().nullable()
+});
+var IdArraySchema = z36.array(z36.number().int().positive());
+var SetPriceListAssignmentsSchema = z36.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: z36.ZodIssueCode.custom,
+        path: [field],
+        message: "Target ids must be unique"
+      });
+    }
+  }
+});
+var ProductPriceSchema = z36.object({
+  id: z36.number().int().positive(),
+  priceListId: z36.number().int().positive(),
+  productPackageId: z36.number().int().positive(),
+  priceAmount: z36.string().regex(/^\d+$/),
+  createdAt: z36.string(),
+  updatedAt: z36.string()
+});
+var ProductPriceInputSchema = z36.object({
+  productPackageId: z36.number().int().positive(),
+  priceAmount: z36.string().regex(/^\d+$/)
+});
+var UpdatePriceListPricesSchema = z36.object({
+  upserted: z36.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: z36.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: z36.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: z36.ZodIssueCode.custom,
+      path: ["removedProductPackageIds"],
+      message: "A product package cannot be updated and removed in the same request"
+    });
+  }
+});
 export {
   ALL_PERMISSIONS,
   CharacteristicSchema,
@@ -577,6 +750,7 @@ export {
   CreateProductTypeSchema,
   CreateRoleSchema,
   CreateWarehouseSchema,
+  CurrencyCodeSchema,
   EmployeeRoleSchema,
   EmployeeSchema,
   FolderSchema,
@@ -584,31 +758,49 @@ export {
   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.js.map