@atomic-solutions/woocommerce-api-client 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -1,8 +1,5 @@
 import axios, { isAxiosError } from 'axios';
-import { productCategorySchema, productSchema, cartSchema, checkoutSchema, storeApiOrderSchema } from '@atomic-solutions/schemas/woocommerce/store-api';
-export { addToCartInputSchema, addressSchema, billingAddressSchemaMandatory as billingAddressSchema, cartItemImageSchema, cartSchema, checkoutInputSchema, checkoutSchema, couponInputSchema, paginationMetaSchema, paginationParamsSchema, productCategorySchema, productImageSchema, productSchema, removeCartItemInputSchema, searchParamsSchema, selectShippingRateInputSchema, storeApiOrderSchema, updateCartItemInputSchema, updateCustomerInputSchema } from '@atomic-solutions/schemas/woocommerce/store-api';
 import { z } from 'zod';
-export { categoryFilterSchema as adminCategoryFilterSchema, couponFilterSchema as adminCouponFilterSchema, couponSchema as adminCouponSchema, orderFilterSchema as adminOrderFilterSchema, orderSchema as adminOrderSchema, productCategorySchema as adminProductCategorySchema, productFilterSchema as adminProductFilterSchema, productSchema as adminProductSchema, createCategorySchema, createCouponSchema, createCustomerSchema, customerFilterSchema, customerSchema, getAppEnumRaw, getAppEnumZod, paymentMethodFilterSchema, paymentMethodSchema, schemas, updateCustomerSchema, wcErrorResponseSchema } from '@atomic-solutions/schemas/woocommerce/admin-api';
 
 // src/client/createClient.ts
 
@@ -629,6 +626,837 @@ var setupErrorInterceptor = (axiosInstance, config, client) => {
     }
   );
 };
+var addressSchema = z.object({
+  /** First name */
+  first_name: z.string().min(1, "First name is required"),
+  /** Last name */
+  last_name: z.string().min(1, "Last name is required"),
+  /** Company name (optional) */
+  company: z.string(),
+  /** Address line 1 */
+  address_1: z.string().min(1, "Address is required"),
+  /** Address line 2 (optional) */
+  address_2: z.string(),
+  /** City */
+  city: z.string().min(1, "City is required"),
+  /** State/Province/Region */
+  state: z.string(),
+  /** Postal code */
+  postcode: z.string().min(1, "Postal code is required"),
+  /** Country code (ISO 3166-1 alpha-2) */
+  country: z.string(),
+  /** Phone number */
+  phone: z.string().min(1, "Phone number is required")
+});
+var addressSchemaNonMandatory = z.object({
+  /** First name */
+  first_name: z.string(),
+  /** Last name */
+  last_name: z.string(),
+  /** Company name (optional) */
+  company: z.string(),
+  /** Address line 1 */
+  address_1: z.string(),
+  /** Address line 2 (optional) */
+  address_2: z.string(),
+  /** City */
+  city: z.string(),
+  /** State/Province/Region */
+  state: z.string(),
+  /** Postal code */
+  postcode: z.string(),
+  /** Country code (ISO 3166-1 alpha-2) */
+  country: z.string(),
+  /** Phone number */
+  phone: z.string()
+});
+var billingAddressSchemaMandatory = addressSchema.extend({
+  /** Email address (required for billing) */
+  email: z.string().email("Valid email is required")
+});
+var billingAddressSchemaNonMandatory = addressSchemaNonMandatory.extend({
+  /** Email address (can be null for guest carts) */
+  email: z.string().nullable()
+});
+var moneySchema = z.object({
+  /** Currency code (e.g., 'USD', 'EUR', 'BAM') */
+  currency_code: z.string(),
+  /** Currency symbol (e.g., '$', '€', 'KM') */
+  currency_symbol: z.string(),
+  /** Number of decimal places (e.g., 2 for dollars/euros) */
+  currency_minor_unit: z.number(),
+  /** Decimal separator character (e.g., '.', ',') */
+  currency_decimal_separator: z.string(),
+  /** Thousands separator character (e.g., ',', '.') */
+  currency_thousand_separator: z.string(),
+  /** Currency symbol prefix (empty if symbol is suffix) */
+  currency_prefix: z.string(),
+  /** Currency symbol suffix (empty if symbol is prefix) */
+  currency_suffix: z.string()
+});
+var paginationParamsSchema = z.object({
+  /** Current page number */
+  page: z.number().int().positive().optional(),
+  /** Items per page */
+  per_page: z.number().int().positive().max(100).optional(),
+  /** Offset for pagination */
+  offset: z.number().int().nonnegative().optional(),
+  /** Sort order */
+  order: z.enum(["asc", "desc"]).optional(),
+  /** Field to sort by */
+  orderby: z.string().optional()
+});
+var paginationMetaSchema = z.object({
+  /** Total number of items */
+  total: z.number(),
+  /** Total number of pages */
+  totalPages: z.number(),
+  /** Current page */
+  currentPage: z.number(),
+  /** Items per page */
+  perPage: z.number()
+});
+var productImageSchema = z.object({
+  /** Alternative text for the image */
+  alt: z.string(),
+  /** Image unique identifier */
+  id: z.number(),
+  /** Image filename */
+  name: z.string(),
+  /** Available image sizes in JSON format */
+  sizes: z.string(),
+  /** Full-size image URL */
+  src: z.string().url(),
+  /** Srcset attribute for responsive images */
+  srcset: z.string(),
+  /** Thumbnail image URL */
+  thumbnail: z.string().url()
+});
+var cartItemImageSchema = z.object({
+  /** Image ID */
+  id: z.number(),
+  /** Full image URL */
+  src: z.string(),
+  /** Thumbnail URL */
+  thumbnail: z.string(),
+  /** Responsive image srcset */
+  srcset: z.string(),
+  /** Responsive image sizes */
+  sizes: z.string(),
+  /** Image name */
+  name: z.string(),
+  /** Image alt text */
+  alt: z.string()
+});
+var pricesSchema = z.object({
+  /** Current active price (sale price if on sale, otherwise regular) */
+  price: z.string(),
+  /** Regular price (before any discounts) */
+  regular_price: z.string(),
+  /** Sale price (empty string if not on sale) */
+  sale_price: z.string(),
+  /** Price range for variable products (null for simple products) */
+  price_range: z.object({
+    min_amount: z.string(),
+    max_amount: z.string()
+  }).nullable(),
+  /** Raw price data without formatting */
+  raw_prices: z.object({
+    /** Decimal precision */
+    precision: z.number(),
+    /** Raw price value */
+    price: z.string(),
+    /** Raw regular price value */
+    regular_price: z.string(),
+    /** Raw sale price value */
+    sale_price: z.string()
+  }).optional()
+}).merge(moneySchema);
+var itemTotalsSchema = z.object({
+  /** Subtotal before taxes */
+  line_subtotal: z.string(),
+  /** Tax amount on subtotal */
+  line_subtotal_tax: z.string(),
+  /** Total after discounts, before taxes */
+  line_total: z.string(),
+  /** Tax amount on total */
+  line_total_tax: z.string()
+}).merge(moneySchema);
+var cartItemSchema = z.object({
+  /** Unique cart item key (use this for update/remove operations) */
+  key: z.string(),
+  /** Product ID */
+  id: z.number(),
+  /** Quantity of this item in cart */
+  quantity: z.number(),
+  /** Quantity limits for this product */
+  quantity_limits: z.object({
+    /** Minimum quantity allowed */
+    minimum: z.number(),
+    /** Maximum quantity allowed */
+    maximum: z.number(),
+    /** Quantity must be multiple of this value */
+    multiple_of: z.number(),
+    /** Whether quantity can be changed */
+    editable: z.boolean()
+  }),
+  /** Product name */
+  name: z.string(),
+  /** Short product description */
+  short_description: z.string(),
+  /** Full product description */
+  description: z.string(),
+  /** Product SKU */
+  sku: z.string(),
+  /** Remaining stock count if low (null if not low or unlimited) */
+  low_stock_remaining: z.number().nullable(),
+  /** Whether backorders are allowed */
+  backorders_allowed: z.boolean(),
+  /** Whether to show backorder badge */
+  show_backorder_badge: z.boolean(),
+  /** Whether product can only be purchased individually */
+  sold_individually: z.boolean(),
+  /** Product permalink URL */
+  permalink: z.string(),
+  /** Product images */
+  images: z.array(cartItemImageSchema),
+  /** Variation attributes (for variable products) */
+  variation: z.array(
+    z.object({
+      /** Attribute name (e.g., 'Color', 'Size') */
+      attribute: z.string(),
+      /** Selected value (e.g., 'Red', 'Large') */
+      value: z.string()
+    })
+  ),
+  /** Additional item data/metadata */
+  item_data: z.array(
+    z.object({
+      key: z.string(),
+      value: z.string()
+    })
+  ),
+  /** Product pricing information */
+  prices: pricesSchema,
+  /** Line item totals */
+  totals: itemTotalsSchema,
+  /** Catalog visibility setting */
+  catalog_visibility: z.string(),
+  /** Product type */
+  type: z.enum(["simple", "variable", "grouped", "external"]),
+  /** Extension data from plugins */
+  extensions: z.record(z.string(), z.unknown())
+});
+var cartTotalsSchema = z.object({
+  /** Total of all cart items (before discounts and taxes) */
+  total_items: z.string(),
+  /** Tax on cart items */
+  total_items_tax: z.string(),
+  /** Total fees */
+  total_fees: z.string(),
+  /** Tax on fees */
+  total_fees_tax: z.string(),
+  /** Total discount amount from coupons */
+  total_discount: z.string(),
+  /** Tax on discounts */
+  total_discount_tax: z.string(),
+  /** Shipping cost (null if not calculated yet) */
+  total_shipping: z.string().nullable(),
+  /** Shipping tax (null if not calculated yet) */
+  total_shipping_tax: z.string().nullable(),
+  /** Final total price (includes all taxes and fees) */
+  total_price: z.string(),
+  /** Total tax amount */
+  total_tax: z.string(),
+  /** Tax breakdown by rate */
+  tax_lines: z.array(
+    z.object({
+      /** Tax rate name */
+      name: z.string(),
+      /** Tax amount */
+      price: z.string(),
+      /** Tax rate percentage */
+      rate: z.string()
+    })
+  )
+}).merge(moneySchema);
+var cartCouponSchema = z.object({
+  /** Coupon code */
+  code: z.string(),
+  /** Discount totals for this coupon */
+  totals: z.object({
+    /** Total discount amount (before tax) */
+    total_discount: z.string(),
+    /** Tax amount on discount */
+    total_discount_tax: z.string()
+  }).merge(moneySchema)
+});
+var shippingRateSchema = z.object({
+  /** Unique rate identifier (format: instance_id:method_id) */
+  rate_id: z.string(),
+  /** Shipping method name */
+  name: z.string(),
+  /** Shipping method description */
+  description: z.string(),
+  /** Estimated delivery time */
+  delivery_time: z.string(),
+  /** Shipping cost */
+  price: z.string(),
+  /** Shipping instance ID */
+  instance_id: z.number(),
+  /** Shipping method ID */
+  method_id: z.string(),
+  /** Additional metadata for this shipping method */
+  meta_data: z.array(
+    z.object({
+      key: z.string(),
+      value: z.string()
+    })
+  ),
+  /** Whether this rate is currently selected */
+  selected: z.boolean(),
+  /** Currency code for the price */
+  currency_code: z.string(),
+  /** Currency symbol for the price */
+  currency_symbol: z.string()
+});
+var shippingPackageSchema = z.object({
+  /** Package identifier (0-indexed) */
+  package_id: z.number(),
+  /** Package name/label */
+  name: z.string(),
+  /** Shipping destination address */
+  destination: z.object({
+    address_1: z.string(),
+    address_2: z.string().optional(),
+    city: z.string(),
+    state: z.string(),
+    postcode: z.string(),
+    country: z.string()
+  }),
+  /** Items included in this package */
+  items: z.array(
+    z.object({
+      /** Cart item key */
+      key: z.string(),
+      /** Product name */
+      name: z.string(),
+      /** Quantity in package */
+      quantity: z.number()
+    })
+  ),
+  /** Available shipping rates for this package */
+  shipping_rates: z.array(shippingRateSchema)
+});
+var cartSchema = z.object({
+  items: z.array(cartItemSchema),
+  items_count: z.number(),
+  items_weight: z.number(),
+  needs_payment: z.boolean(),
+  needs_shipping: z.boolean(),
+  payment_methods: z.array(z.enum(["cod", "monri"])),
+  payment_requirements: z.array(z.string()),
+  has_calculated_shipping: z.boolean(),
+  shipping_address: addressSchemaNonMandatory,
+  billing_address: billingAddressSchemaNonMandatory,
+  shipping_rates: z.array(shippingPackageSchema),
+  coupons: z.array(cartCouponSchema),
+  totals: cartTotalsSchema,
+  errors: z.array(
+    z.object({
+      code: z.string(),
+      message: z.string()
+    })
+  ),
+  extensions: z.record(z.string(), z.unknown()).optional(),
+  cross_sells: z.array(z.unknown()),
+  fees: z.array(z.unknown())
+});
+var addToCartInputSchema = z.object({
+  id: z.number(),
+  quantity: z.number().int().positive(),
+  variation: z.array(
+    z.object({
+      attribute: z.string(),
+      value: z.string()
+    })
+  ).optional()
+});
+var updateCartItemInputSchema = z.object({
+  key: z.string(),
+  quantity: z.number().int().positive()
+});
+var removeCartItemInputSchema = z.object({
+  key: z.string()
+});
+var couponInputSchema = z.object({
+  code: z.string().min(1)
+});
+var updateCustomerInputSchema = z.object({
+  billing_address: billingAddressSchemaMandatory.partial(),
+  shipping_address: addressSchema.partial()
+}).partial();
+var selectShippingRateInputSchema = z.object({
+  package_id: z.union([z.number(), z.string()]).default(0),
+  rate_id: z.string()
+});
+var orderItemImageSchema = z.object({
+  /** Image ID */
+  id: z.number(),
+  /** Full image URL */
+  src: z.string().url(),
+  /** Thumbnail URL */
+  thumbnail: z.string().url(),
+  /** Responsive image srcset */
+  srcset: z.string(),
+  /** Responsive image sizes attribute */
+  sizes: z.string(),
+  /** Image name */
+  name: z.string(),
+  /** Image alt text */
+  alt: z.string()
+});
+var orderItemPricesSchema = z.object({
+  /** Formatted price (current price) */
+  price: z.string(),
+  /** Formatted regular price */
+  regular_price: z.string(),
+  /** Formatted sale price */
+  sale_price: z.string(),
+  /** Price range (null for simple products) */
+  price_range: z.null(),
+  /** Currency code (e.g., 'USD', 'EUR') */
+  currency_code: z.string(),
+  /** Currency symbol (e.g., '$', '€') */
+  currency_symbol: z.string(),
+  /** Number of decimal places for currency */
+  currency_minor_unit: z.number(),
+  /** Decimal separator (e.g., '.', ',') */
+  currency_decimal_separator: z.string(),
+  /** Thousand separator (e.g., ',', '.') */
+  currency_thousand_separator: z.string(),
+  /** Currency prefix (e.g., '$') */
+  currency_prefix: z.string(),
+  /** Currency suffix (e.g., 'USD') */
+  currency_suffix: z.string(),
+  /** Raw price values for calculations */
+  raw_prices: z.object({
+    /** Precision for price calculations */
+    precision: z.number(),
+    /** Raw price (in minor units) */
+    price: z.string(),
+    /** Raw regular price (in minor units) */
+    regular_price: z.string(),
+    /** Raw sale price (in minor units) */
+    sale_price: z.string()
+  })
+});
+var orderItemTotalsSchema = z.object({
+  /** Line subtotal (before discounts) */
+  line_subtotal: z.string(),
+  /** Line subtotal tax */
+  line_subtotal_tax: z.string(),
+  /** Line total (after discounts) */
+  line_total: z.string(),
+  /** Line total tax */
+  line_total_tax: z.string(),
+  /** Currency code */
+  currency_code: z.string(),
+  /** Currency symbol */
+  currency_symbol: z.string(),
+  /** Currency minor unit */
+  currency_minor_unit: z.number(),
+  /** Decimal separator */
+  currency_decimal_separator: z.string(),
+  /** Thousand separator */
+  currency_thousand_separator: z.string(),
+  /** Currency prefix */
+  currency_prefix: z.string(),
+  /** Currency suffix */
+  currency_suffix: z.string()
+});
+var quantityLimitsSchema = z.object({
+  /** Minimum quantity allowed */
+  minimum: z.number(),
+  /** Maximum quantity allowed */
+  maximum: z.number(),
+  /** Quantity must be multiple of this value */
+  multiple_of: z.number(),
+  /** Whether quantity is editable */
+  editable: z.boolean()
+});
+var orderItemSchema = z.object({
+  /** Unique cart/order item key */
+  key: z.string(),
+  /** Product ID */
+  id: z.number(),
+  /** Quantity ordered */
+  quantity: z.number(),
+  /** Quantity limits for this product */
+  quantity_limits: quantityLimitsSchema,
+  /** Product name */
+  name: z.string(),
+  /** Short description */
+  short_description: z.string(),
+  /** Full description */
+  description: z.string(),
+  /** Product SKU */
+  sku: z.string(),
+  /** Low stock warning (null if not low) */
+  low_stock_remaining: z.null(),
+  /** Whether backorders are allowed */
+  backorders_allowed: z.boolean(),
+  /** Whether to show backorder badge */
+  show_backorder_badge: z.boolean(),
+  /** Whether product can only be purchased individually */
+  sold_individually: z.boolean(),
+  /** Product permalink URL */
+  permalink: z.string().url(),
+  /** Product images */
+  images: z.array(orderItemImageSchema),
+  /** Variation attributes (empty for simple products) */
+  variation: z.array(z.unknown()),
+  /** Custom item data/metadata */
+  item_data: z.array(z.unknown()),
+  /** Price information */
+  prices: orderItemPricesSchema,
+  /** Totals for this line item */
+  totals: orderItemTotalsSchema,
+  /** Catalog visibility setting */
+  catalog_visibility: z.string()
+});
+var orderTotalsSchema = z.object({
+  /** Subtotal (before discounts and fees) */
+  subtotal: z.string(),
+  /** Total discount amount */
+  total_discount: z.string(),
+  /** Total shipping cost */
+  total_shipping: z.string(),
+  /** Total fees */
+  total_fees: z.string(),
+  /** Total tax */
+  total_tax: z.string(),
+  /** Total refund amount */
+  total_refund: z.string(),
+  /** Final total price */
+  total_price: z.string(),
+  /** Total items cost (subtotal after item-level discounts) */
+  total_items: z.string(),
+  /** Tax on items */
+  total_items_tax: z.string(),
+  /** Tax on fees */
+  total_fees_tax: z.string(),
+  /** Tax on discounts */
+  total_discount_tax: z.string(),
+  /** Tax on shipping */
+  total_shipping_tax: z.string(),
+  /** Tax line items breakdown */
+  tax_lines: z.array(z.unknown()),
+  /** Currency code (e.g., 'USD', 'EUR', 'BAM') */
+  currency_code: z.string(),
+  /** Currency symbol (e.g., '$', '€', 'KM') */
+  currency_symbol: z.string(),
+  /** Number of decimal places for currency */
+  currency_minor_unit: z.number(),
+  /** Decimal separator (e.g., '.', ',') */
+  currency_decimal_separator: z.string(),
+  /** Thousand separator (e.g., ',', '.') */
+  currency_thousand_separator: z.string(),
+  /** Currency prefix (e.g., '$') */
+  currency_prefix: z.string(),
+  /** Currency suffix (e.g., 'USD') */
+  currency_suffix: z.string()
+});
+var orderStatusEnum = z.enum([
+  "pending",
+  // Order received, awaiting payment
+  "processing",
+  // Payment received, order is being processed
+  "on-hold",
+  // Order on hold, awaiting confirmation
+  "completed",
+  // Order fulfilled and complete
+  "cancelled",
+  // Order cancelled by customer or admin
+  "refunded",
+  // Order refunded
+  "failed"
+  // Payment failed or order declined
+]);
+var storeApiOrderSchema = z.object({
+  /** Order ID */
+  id: z.number(),
+  /** Order status */
+  status: orderStatusEnum,
+  /** Order line items (products purchased) */
+  items: z.array(orderItemSchema),
+  /** Applied coupons */
+  coupons: z.array(z.unknown()),
+  /** Order fees */
+  fees: z.array(z.unknown()),
+  /** Order totals breakdown */
+  totals: orderTotalsSchema,
+  /** Shipping address */
+  shipping_address: addressSchema,
+  /** Billing address (includes email) */
+  billing_address: billingAddressSchemaMandatory,
+  /** Whether order still needs payment */
+  needs_payment: z.boolean(),
+  /** Whether order needs shipping */
+  needs_shipping: z.boolean(),
+  /** Payment method requirements */
+  payment_requirements: z.array(z.string()),
+  /** Order errors (if any) */
+  errors: z.array(z.unknown()),
+  /** Payment method (optional - returned from checkout) */
+  payment_method: z.string().optional(),
+  /** Payment method title (optional - returned from checkout) */
+  payment_method_title: z.string().optional()
+});
+z.object({
+  id: z.number(),
+  status: z.string(),
+  order_key: z.string(),
+  number: z.string(),
+  currency: z.string(),
+  total: z.string(),
+  date_created: z.string(),
+  customer_note: z.string(),
+  billing: z.record(z.string(), z.unknown()),
+  shipping: z.record(z.string(), z.unknown()),
+  payment_method: z.string(),
+  payment_method_title: z.string(),
+  line_items: z.array(z.unknown())
+});
+var checkoutSchema = z.object({
+  order_id: z.number(),
+  status: z.string(),
+  order_key: z.string(),
+  customer_note: z.string(),
+  customer_id: z.number(),
+  billing_address: billingAddressSchemaNonMandatory,
+  shipping_address: addressSchemaNonMandatory,
+  payment_method: z.string(),
+  payment_result: z.object({
+    payment_status: z.string(),
+    payment_details: z.array(z.unknown()),
+    redirect_url: z.string()
+  })
+});
+var checkoutInputSchema = z.object({
+  payment_method: z.string(),
+  payment_data: z.array(
+    z.object({
+      key: z.string(),
+      value: z.union([z.string(), z.boolean()])
+    })
+  ).optional(),
+  billing_address: billingAddressSchemaMandatory.optional(),
+  shipping_address: addressSchema.optional(),
+  customer_note: z.string().optional(),
+  create_account: z.boolean().optional(),
+  extensions: z.record(z.string(), z.unknown()).optional()
+});
+var addToCartSchema = z.object({
+  /** Description for add to cart action */
+  description: z.string(),
+  /** Maximum quantity that can be added */
+  maximum: z.number(),
+  /** Minimum quantity that can be added */
+  minimum: z.number(),
+  /** Quantity must be a multiple of this number */
+  multiple_of: z.number(),
+  /** Text for add to cart button */
+  text: z.string(),
+  /** URL for add to cart action */
+  url: z.string()
+});
+var embeddedCategorySchema = z.object({
+  /** Category unique identifier */
+  id: z.number(),
+  /** Category display name */
+  name: z.string(),
+  /** URL-friendly category identifier */
+  slug: z.string(),
+  /** Link to category page */
+  link: z.string(),
+  /** Parent category ID (0 for root categories) - optional in embedded */
+  parent: z.number().optional(),
+  /** Category description - optional in embedded */
+  description: z.string().optional(),
+  /** Display type - optional in embedded */
+  display: z.string().optional(),
+  /** Category image - optional in embedded */
+  image: productImageSchema.nullable().optional(),
+  /** Menu order for sorting - optional in embedded */
+  menu_order: z.number().optional(),
+  /** Number of products in this category - optional in embedded */
+  count: z.number().optional()
+});
+var productCategorySchema = z.object({
+  /** Category unique identifier */
+  id: z.number(),
+  /** Category display name */
+  name: z.string(),
+  /** URL-friendly category identifier */
+  slug: z.string(),
+  /** Parent category ID (0 for root categories) */
+  parent: z.number(),
+  /** Category description */
+  description: z.string(),
+  /** Category image */
+  image: productImageSchema.nullable(),
+  /** Menu order for sorting */
+  menu_order: z.number().optional(),
+  /** Number of products in this category */
+  count: z.number()
+});
+var storeProductsSearchParamsSchema = z.object({
+  // Pagination
+  /** Current page number */
+  page: z.number(),
+  /** Number of products per page (1-100) */
+  per_page: z.number().min(1).max(100).default(10),
+  // Ordering
+  /** Field to order results by */
+  orderby: z.enum([
+    "date",
+    "id",
+    "include",
+    "title",
+    "slug",
+    "price",
+    "popularity",
+    "rating",
+    "menu_order",
+    "date_modified"
+  ]).optional(),
+  /** Sort order (ascending or descending) */
+  order: z.enum(["asc", "desc"]).optional(),
+  // Filtering
+  /** Search query string */
+  search: z.string().optional(),
+  /** Exact slug match */
+  slug: z.string().optional(),
+  // Date filtering
+  /** Filter products published after this date */
+  after: z.string().datetime().optional(),
+  /** Filter products published before this date */
+  before: z.string().datetime().optional(),
+  /** Filter products modified after this date */
+  modified_after: z.string().datetime().optional(),
+  /** Filter products modified before this date */
+  modified_before: z.string().datetime().optional(),
+  // ID filtering
+  /** Include specific product IDs */
+  include: z.array(z.number()).optional(),
+  /** Exclude specific product IDs */
+  exclude: z.array(z.number()).optional(),
+  // Parent/Child
+  /** Filter by parent product IDs */
+  parent: z.array(z.number()).optional(),
+  /** Exclude products with these parent IDs */
+  parent_exclude: z.array(z.number()).optional(),
+  // Type & Status
+  /** Filter by product type */
+  type: z.enum(["simple", "grouped", "external", "variable", "variation"]).optional(),
+  /** Filter by product status */
+  status: z.enum(["any", "draft", "pending", "private", "publish"]).optional(),
+  // Featured
+  /** Filter featured products */
+  featured: z.boolean().optional(),
+  // Visibility
+  /** Filter by catalog visibility */
+  catalog_visibility: z.enum(["any", "visible", "catalog", "search", "hidden"]).optional(),
+  // Stock
+  /** Filter by stock status */
+  stock_status: z.array(z.enum(["instock", "outofstock", "onbackorder"])).optional(),
+  // Category & Tag filtering
+  /** Filter by category slug or ID */
+  category: z.string().optional(),
+  /** Category filter operator */
+  category_operator: z.enum(["in", "not_in", "and"]).optional(),
+  /** Filter by tag slug or ID */
+  tag: z.string().optional(),
+  /** Tag filter operator */
+  tag_operator: z.enum(["in", "not_in", "and"]).optional(),
+  // Attribute filtering
+  /** Filter by product attributes */
+  attributes: z.array(
+    z.object({
+      /** Attribute name */
+      attribute: z.string(),
+      /** Filter by attribute term IDs */
+      term_id: z.array(z.number()).optional(),
+      /** Filter by attribute term slugs */
+      slug: z.array(z.string()).optional(),
+      /** Attribute filter operator */
+      operator: z.enum(["in", "not_in", "and"]).optional()
+    })
+  ).optional(),
+  /** Relationship between attribute filters */
+  attribute_relation: z.enum(["in", "and"]).optional(),
+  // Price filtering
+  /** Minimum price filter */
+  min_price: z.string().optional(),
+  /** Maximum price filter */
+  max_price: z.string().optional(),
+  // Sale status
+  /** Filter products on sale */
+  on_sale: z.boolean().optional(),
+  // Rating filter
+  /** Filter by product rating (1-5 stars) */
+  rating: z.array(z.number().min(1).max(5)).optional()
+});
+var productSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  slug: z.string(),
+  type: z.string(),
+  variation: z.string(),
+  permalink: z.string().url(),
+  sku: z.string(),
+  short_description: z.string(),
+  description: z.string(),
+  is_purchasable: z.boolean(),
+  is_in_stock: z.boolean(),
+  is_on_backorder: z.boolean(),
+  low_stock_remaining: z.number().nullable(),
+  sold_individually: z.boolean(),
+  add_to_cart: addToCartSchema,
+  has_options: z.boolean(),
+  on_sale: z.boolean(),
+  parent: z.number(),
+  attributes: z.array(z.unknown()),
+  categories: z.array(embeddedCategorySchema),
+  tags: z.array(z.unknown()),
+  images: z.array(productImageSchema),
+  variations: z.array(z.unknown()),
+  price_html: z.string(),
+  prices: pricesSchema,
+  average_rating: z.string(),
+  review_count: z.number(),
+  extensions: z.record(z.string(), z.unknown())
+});
+var paymentDataItemSchema = z.object({
+  /** Key identifier for the payment data field */
+  key: z.string(),
+  /** Value can be string or boolean depending on the field */
+  value: z.union([z.string(), z.boolean()])
+});
+z.object({
+  /** Payment method ID (e.g., "cod", "stripe", "bacs") */
+  payment_method: z.string().min(1, "Payment method is required"),
+  /**
+   * Optional payment gateway-specific data
+   *
+   * Array of key-value pairs that will be passed to the payment gateway
+   * Example: [{ key: "stripe_token", value: "tok_xyz" }]
+   */
+  payment_data: z.array(paymentDataItemSchema).optional()
+});
+
+// src/api/cart.ts
 var createCartAPI = (client, endpoints, options) => ({
   get: async () => {
     const response = await client.get(endpoints.cart);
@@ -663,6 +1491,8 @@ var createCartAPI = (client, endpoints, options) => ({
     return handleApiResponse(response, cartSchema, options);
   }
 });
+
+// src/api/checkout.ts
 var createCheckoutAPI = (client, endpoints, options) => ({
   get: async () => {
     const response = await client.get(endpoints.checkout);
@@ -673,6 +1503,8 @@ var createCheckoutAPI = (client, endpoints, options) => ({
     return handleApiResponse(response, checkoutSchema, options);
   }
 });
+
+// src/api/orders.ts
 var createOrdersAPI = (client, endpoints, options) => ({
   /**
    * Get a single order by ID
@@ -761,7 +1593,526 @@ var createClient = (config) => {
   setupErrorInterceptor(axiosInstance, fullConfig, client);
   return client;
 };
+var ORDER_STATUS = [
+  "cancelled",
+  "completed",
+  "pending",
+  "processing",
+  "on-hold",
+  "auto-draft",
+  "trash",
+  "refunded",
+  "failed",
+  "checkout-draft"
+];
+var PAYMENT_METHODS = ["cod", "monri", "pikpay", "bacs", "cheque"];
+var PRODUCT_TYPES = ["simple", "grouped", "external", "variable"];
+var PRODUCT_STATUS = [
+  "any",
+  "future",
+  "trash",
+  "draft",
+  "pending",
+  "private",
+  "publish"
+];
+var STOCK_STATUS = ["instock", "outofstock", "onbackorder"];
+var USER_ROLES = [
+  "all",
+  "administrator",
+  "editor",
+  "author",
+  "contributor",
+  "subscriber",
+  "customer",
+  "shop_manager",
+  "dc_pending_vendor",
+  "dc_rejected_vendor",
+  "dc_vendor",
+  "translator"
+];
+var REVIEW_STATUS = ["all", "hold", "approved", "spam", "trash"];
+var SORT_ORDER = ["asc", "desc"];
+var COUPONS_ORDER_BY = ["date", "id", "include", "title", "slug", "modified"];
+var PRODUCT_SORT_FIELDS = [
+  "date",
+  "id",
+  "include",
+  "title",
+  "slug",
+  "modified",
+  "popularity",
+  "rating",
+  "menu_order",
+  "price"
+];
+var CATEGORY_SORT_FIELDS = [
+  "id",
+  "include",
+  "name",
+  "slug",
+  "term_group",
+  "description",
+  "count"
+];
+var ORDER_SORT_FIELDS = ["date", "id", "include", "title", "slug", "modified"];
+var ERROR_CODES = ["registration-error-email-exists", "rest_no_route"];
+var CATALOG_VISIBILITY = ["visible", "catalog", "search", "hidden"];
+var CUSTOMER_ROLE = [
+  "all",
+  "administrator",
+  "editor",
+  "author",
+  "contributor",
+  "subscriber",
+  "customer",
+  "shop_manager"
+];
+var CUSTOMER_SORT_FIELDS = ["id", "include", "name", "registered_date"];
+var PRODUCT_REVIEWS_SORT_FIELDS = ["date", "date_gmt", "id", "include", "product"];
+var ENUM_RAW = {
+  ORDER: {
+    STATUS: ORDER_STATUS,
+    SORT_FIELDS: ORDER_SORT_FIELDS
+  },
+  PAYMENT: {
+    METHODS: PAYMENT_METHODS
+  },
+  PRODUCT: {
+    TYPES: PRODUCT_TYPES,
+    STATUS: PRODUCT_STATUS,
+    STOCK_STATUS,
+    CATALOG_VISIBILITY,
+    SORT_FIELDS: PRODUCT_SORT_FIELDS
+  },
+  USER: {
+    ROLES: USER_ROLES
+  },
+  REVIEW: {
+    STATUS: REVIEW_STATUS,
+    SORT_FIELDS: PRODUCT_REVIEWS_SORT_FIELDS
+  },
+  CATEGORY: {
+    SORT_FIELDS: CATEGORY_SORT_FIELDS
+  },
+  COMMON: {
+    SORT_ORDER,
+    ERROR_CODES},
+  CUSTOMER: {
+    ROLE: CUSTOMER_ROLE,
+    SORT_FIELDS: CUSTOMER_SORT_FIELDS
+  },
+  COUPONS: {
+    ORDER_BY: COUPONS_ORDER_BY
+  }
+};
+var APP_ENUMS = {
+  PRODUCT_TYPES: {
+    RAW: ENUM_RAW.PRODUCT.TYPES,
+    ZOD: z.enum(ENUM_RAW.PRODUCT.TYPES)
+  },
+  PRODUCT_STATUS: {
+    RAW: ENUM_RAW.PRODUCT.STATUS,
+    ZOD: z.enum(ENUM_RAW.PRODUCT.STATUS)
+  },
+  PRODUCT_STOCK_STATUS: {
+    RAW: ENUM_RAW.PRODUCT.STOCK_STATUS,
+    ZOD: z.enum(ENUM_RAW.PRODUCT.STOCK_STATUS)
+  },
+  PRODUCT_CATALOG_VISIBILITY: {
+    RAW: ENUM_RAW.PRODUCT.CATALOG_VISIBILITY,
+    ZOD: z.enum(ENUM_RAW.PRODUCT.CATALOG_VISIBILITY)
+  },
+  PRODUCT_SORT_FIELDS: {
+    RAW: ENUM_RAW.PRODUCT.SORT_FIELDS,
+    ZOD: z.enum(ENUM_RAW.PRODUCT.SORT_FIELDS)
+  },
+  ORDER_STATUS: {
+    RAW: ENUM_RAW.ORDER.STATUS,
+    ZOD: z.enum(ENUM_RAW.ORDER.STATUS)
+  },
+  ORDER_SORT_FIELDS: {
+    RAW: ENUM_RAW.ORDER.SORT_FIELDS,
+    ZOD: z.enum(ENUM_RAW.ORDER.SORT_FIELDS)
+  },
+  PAYMENT_METHODS: {
+    RAW: ENUM_RAW.PAYMENT.METHODS,
+    ZOD: z.enum(ENUM_RAW.PAYMENT.METHODS)
+  },
+  USER_ROLES: {
+    RAW: ENUM_RAW.USER.ROLES,
+    ZOD: z.enum(ENUM_RAW.USER.ROLES)
+  },
+  REVIEW_STATUS: {
+    RAW: ENUM_RAW.REVIEW.STATUS,
+    ZOD: z.enum(ENUM_RAW.REVIEW.STATUS)
+  },
+  CATEGORY_SORT_FIELDS: {
+    RAW: ENUM_RAW.CATEGORY.SORT_FIELDS,
+    ZOD: z.enum(ENUM_RAW.CATEGORY.SORT_FIELDS)
+  },
+  COMMON_SORT_ORDER: {
+    RAW: ENUM_RAW.COMMON.SORT_ORDER,
+    ZOD: z.enum(ENUM_RAW.COMMON.SORT_ORDER)
+  },
+  COMMON_ERROR_CODES: {
+    RAW: ENUM_RAW.COMMON.ERROR_CODES,
+    ZOD: z.enum(ENUM_RAW.COMMON.ERROR_CODES)
+  },
+  CUSTOMER_ROLE: {
+    RAW: ENUM_RAW.CUSTOMER.ROLE,
+    ZOD: z.enum(ENUM_RAW.CUSTOMER.ROLE)
+  },
+  CUSTOMER_SORT_FIELDS: {
+    RAW: ENUM_RAW.CUSTOMER.SORT_FIELDS,
+    ZOD: z.enum(ENUM_RAW.CUSTOMER.SORT_FIELDS)
+  },
+  REVIEW_SORT_FIELDS: {
+    RAW: ENUM_RAW.REVIEW.SORT_FIELDS,
+    ZOD: z.enum(ENUM_RAW.REVIEW.SORT_FIELDS)
+  },
+  COUPONS_ORDER_BY: {
+    RAW: ENUM_RAW.COUPONS.ORDER_BY,
+    ZOD: z.enum(ENUM_RAW.COUPONS.ORDER_BY)
+  }
+};
+var getAppEnumZod = (key) => APP_ENUMS[key].ZOD;
+var getAppEnumRaw = (key) => APP_ENUMS[key].RAW;
+var basePaginationSchema = z.object({
+  page: z.number().positive().default(1),
+  per_page: z.number().positive().max(100).default(10),
+  offset: z.number().nonnegative().optional()
+});
+var baseFilteringSchema = z.object({
+  search: z.string().optional(),
+  exclude: z.array(z.number()).default([]),
+  include: z.array(z.number()).default([])
+});
+z.object({
+  status: z.enum(["publish", "future", "draft", "pending", "private"]).optional()
+});
+z.object({
+  "x-wp-total": z.string().transform(Number),
+  "x-wp-totalpages": z.string().transform(Number)
+});
+z.object({
+  ...basePaginationSchema.shape,
+  ...baseFilteringSchema.shape,
+  context: z.enum(["view", "edit"]).default("view")
+});
+var wpLinksSchema = z.object({
+  self: z.array(z.object({ href: z.string() })),
+  collection: z.array(z.object({ href: z.string() })),
+  about: z.array(z.object({ href: z.string() })).optional(),
+  author: z.array(
+    z.object({
+      embeddable: z.boolean().optional(),
+      href: z.string()
+    })
+  ).optional()
+});
+var wcSortingSchema = z.object({
+  order: getAppEnumZod("COMMON_SORT_ORDER").default("desc"),
+  orderby: z.string().optional()
+});
+var wcDateFilterSchema = z.object({
+  after: z.string().datetime().optional(),
+  before: z.string().datetime().optional(),
+  modified_after: z.string().datetime().optional(),
+  modified_before: z.string().datetime().optional(),
+  dates_are_gmt: z.boolean().default(false)
+});
+var wcMetaDataSchema = z.object({
+  id: z.number(),
+  key: z.string(),
+  value: z.any()
+});
+var wcAddressSchema = z.object({
+  first_name: z.string().default(""),
+  last_name: z.string().default(""),
+  company: z.string().default(""),
+  address_1: z.string().default(""),
+  address_2: z.string().default(""),
+  city: z.string().default(""),
+  state: z.string().default(""),
+  postcode: z.string().default(""),
+  country: z.string().default("BA"),
+  phone: z.string().default(""),
+  email: z.string().email().optional()
+});
+var wcBaseParamsSchema = z.object({
+  ...basePaginationSchema.shape,
+  ...baseFilteringSchema.shape,
+  ...wcSortingSchema.shape
+});
+var wcBaseResponseSchema = z.object({
+  _links: wpLinksSchema,
+  meta_data: z.array(wcMetaDataSchema).optional()
+});
+z.object({
+  total: z.number(),
+  totalPages: z.number(),
+  currentPage: z.number(),
+  perPage: z.number()
+});
+var wcErrorResponseSchema = z.object({
+  code: getAppEnumZod("COMMON_ERROR_CODES"),
+  message: z.string(),
+  data: z.object({
+    status: z.number()
+  }).optional()
+}).passthrough();
+var couponFilterSchema = wcBaseParamsSchema.extend({
+  orderby: getAppEnumZod("COUPONS_ORDER_BY").default("date"),
+  code: z.string().optional()
+});
+var couponSchema = wcBaseResponseSchema.extend({
+  id: z.number(),
+  code: z.string(),
+  amount: z.string(),
+  status: z.string(),
+  discount_type: z.enum(["percent", "fixed_cart", "fixed_product"]),
+  description: z.string(),
+  date_expires: z.string().nullable(),
+  usage_count: z.number(),
+  individual_use: z.boolean(),
+  product_ids: z.array(z.number()),
+  excluded_product_ids: z.array(z.number()),
+  usage_limit: z.number().nullable(),
+  usage_limit_per_user: z.number().nullable(),
+  limit_usage_to_x_items: z.number().nullable(),
+  free_shipping: z.boolean(),
+  product_categories: z.array(z.number()),
+  excluded_product_categories: z.array(z.number()),
+  exclude_sale_items: z.boolean(),
+  minimum_amount: z.string(),
+  maximum_amount: z.string(),
+  email_restrictions: z.array(z.string())
+});
+var createCouponSchema = couponSchema.omit({
+  id: true,
+  usage_count: true
+}).extend({
+  code: z.string().min(1, "Code is required"),
+  amount: z.string().min(1, "Amount is required")
+});
+var customerFilterSchema = wcBaseParamsSchema.extend({
+  orderby: getAppEnumZod("CUSTOMER_SORT_FIELDS").default("name"),
+  role: getAppEnumZod("CUSTOMER_ROLE").default("customer"),
+  email: z.string().email().optional()
+});
+var customerSchema = wcBaseResponseSchema.extend({
+  id: z.number(),
+  username: z.string(),
+  first_name: z.string(),
+  last_name: z.string(),
+  email: z.string().email(),
+  role: getAppEnumZod("CUSTOMER_ROLE"),
+  date_created: z.string(),
+  date_modified: z.string(),
+  is_paying_customer: z.boolean(),
+  avatar_url: z.string(),
+  billing: wcAddressSchema.extend({
+    email: z.string().email()
+  }),
+  shipping: wcAddressSchema
+});
+var createCustomerSchema = customerSchema.pick({
+  email: true,
+  first_name: true,
+  last_name: true,
+  shipping: true
+}).extend({
+  loyalty_card_number: z.string().optional()
+});
+var updateCustomerSchema = createCustomerSchema.merge(
+  customerSchema.pick({
+    billing: true
+  })
+).partial();
+var orderFilterSchema = wcBaseParamsSchema.extend({
+  orderby: getAppEnumZod("ORDER_SORT_FIELDS").default("date"),
+  status: z.array(getAppEnumZod("ORDER_STATUS")).optional(),
+  customer: z.number().optional(),
+  product: z.number().optional(),
+  dp: z.number().default(2).optional()
+  // decimal points
+}).merge(wcDateFilterSchema);
+var orderLineItemSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  product_id: z.number(),
+  variation_id: z.number(),
+  quantity: z.number(),
+  tax_class: z.string(),
+  subtotal: z.string(),
+  subtotal_tax: z.string(),
+  total: z.string(),
+  total_tax: z.string(),
+  sku: z.string(),
+  price: z.number()
+});
+var orderSchema2 = wcBaseResponseSchema.extend({
+  id: z.number(),
+  parent_id: z.number(),
+  status: getAppEnumZod("ORDER_STATUS"),
+  currency: z.string(),
+  version: z.string(),
+  prices_include_tax: z.boolean(),
+  date_created: z.string(),
+  date_modified: z.string(),
+  discount_total: z.string(),
+  shipping_total: z.string(),
+  cart_tax: z.string(),
+  total: z.string(),
+  customer_id: z.number(),
+  order_key: z.string(),
+  billing: wcAddressSchema.extend({
+    email: z.string().email()
+  }),
+  shipping: wcAddressSchema,
+  payment_method: getAppEnumZod("PAYMENT_METHODS"),
+  payment_method_title: z.string(),
+  line_items: z.array(orderLineItemSchema),
+  // specific fields
+  payment_url: z.string().optional(),
+  pikpay_transaction_id: z.string().optional(),
+  pikpay_status: z.string().optional(),
+  monri_transaction_id: z.string().optional(),
+  monri_status: z.string().optional()
+});
+var paymentMethodFilterSchema = wcBaseParamsSchema.extend({
+  enabled: z.boolean().optional()
+});
+var paymentMethodSchema2 = wcBaseResponseSchema.extend({
+  id: getAppEnumZod("PAYMENT_METHODS"),
+  title: z.string(),
+  description: z.string(),
+  enabled: z.boolean(),
+  method_title: z.string(),
+  method_description: z.string()
+});
+var categoryFilterSchema = wcBaseParamsSchema.extend({
+  orderby: getAppEnumZod("CATEGORY_SORT_FIELDS").default("name"),
+  hide_empty: z.boolean().default(false),
+  parent: z.number().optional(),
+  product: z.number().nullable().default(null),
+  slug: z.string().optional()
+});
+var productImageSchema2 = z.object({
+  id: z.number(),
+  date_created: z.string(),
+  date_modified: z.string(),
+  src: z.string(),
+  name: z.string(),
+  alt: z.string()
+});
+var productSchema2 = wcBaseResponseSchema.extend({
+  id: z.number(),
+  name: z.string(),
+  slug: z.string(),
+  date_created: z.string(),
+  date_modified: z.string(),
+  type: z.string(),
+  status: z.string(),
+  featured: z.boolean(),
+  catalog_visibility: z.string(),
+  description: z.string(),
+  short_description: z.string(),
+  sku: z.string(),
+  price: z.string(),
+  regular_price: z.string(),
+  sale_price: z.string(),
+  stock_status: getAppEnumZod("PRODUCT_STOCK_STATUS"),
+  stock_quantity: z.number().nullable(),
+  categories: z.array(
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      slug: z.string()
+    })
+  ),
+  images: z.array(productImageSchema2),
+  attributes: z.array(
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      position: z.number(),
+      visible: z.boolean(),
+      variation: z.boolean(),
+      options: z.array(z.string())
+    })
+  ),
+  meta_data: z.array(wcMetaDataSchema),
+  on_sale: z.boolean(),
+  manufacturer: z.string().optional()
+});
+var productCategorySchema2 = wcBaseResponseSchema.extend({
+  id: z.number(),
+  name: z.string(),
+  slug: z.string(),
+  parent: z.number(),
+  description: z.string(),
+  display: z.string(),
+  image: productImageSchema2.nullable(),
+  menu_order: z.number(),
+  count: z.number()
+});
+var productFilterSchema = wcBaseParamsSchema.extend({
+  orderby: getAppEnumZod("PRODUCT_SORT_FIELDS").default("date"),
+  status: getAppEnumZod("PRODUCT_STATUS").default("any"),
+  type: getAppEnumZod("PRODUCT_TYPES").optional(),
+  sku: z.string().optional(),
+  featured: z.boolean().optional(),
+  category: z.string().optional(),
+  tag: z.string().optional(),
+  shipping_class: z.string().optional(),
+  attribute: z.string().optional(),
+  attribute_term: z.string().optional(),
+  stock_status: getAppEnumZod("PRODUCT_STOCK_STATUS").optional(),
+  on_sale: z.boolean().optional(),
+  min_price: z.string().optional(),
+  max_price: z.string().optional()
+}).merge(wcDateFilterSchema);
+var createCategorySchema = productCategorySchema2.omit({
+  id: true,
+  count: true
+}).extend({
+  name: z.string().min(1, "Name is required")
+});
+var schemas = {
+  resources: {
+    product: {
+      filter: productFilterSchema,
+      entity: productSchema2,
+      category: {
+        filter: categoryFilterSchema,
+        entity: productCategorySchema2
+      }
+    },
+    order: {
+      filter: orderFilterSchema,
+      entity: orderSchema2,
+      lineItem: orderLineItemSchema
+    },
+    customer: {
+      filter: customerFilterSchema,
+      entity: customerSchema,
+      create: createCustomerSchema,
+      update: updateCustomerSchema
+    },
+    coupon: {
+      filter: couponFilterSchema,
+      entity: couponSchema,
+      create: createCouponSchema
+    },
+    paymentMethod: {
+      filter: paymentMethodFilterSchema,
+      entity: paymentMethodSchema2
+    }
+  }
+};
 
-export { WooCommerceApiError, WooCommerceDataValidationError, createClient };
+export { WooCommerceApiError, WooCommerceDataValidationError, addToCartInputSchema, addressSchema, categoryFilterSchema as adminCategoryFilterSchema, couponFilterSchema as adminCouponFilterSchema, couponSchema as adminCouponSchema, orderFilterSchema as adminOrderFilterSchema, orderSchema2 as adminOrderSchema, productCategorySchema2 as adminProductCategorySchema, productFilterSchema as adminProductFilterSchema, productSchema2 as adminProductSchema, billingAddressSchemaMandatory as billingAddressSchema, cartItemImageSchema, cartSchema, checkoutInputSchema, checkoutSchema, couponInputSchema, createCategorySchema, createClient, createCouponSchema, createCustomerSchema, customerFilterSchema, customerSchema, getAppEnumRaw, getAppEnumZod, paginationMetaSchema, paginationParamsSchema, paymentMethodFilterSchema, paymentMethodSchema2 as paymentMethodSchema, productCategorySchema, productImageSchema, productSchema, removeCartItemInputSchema, schemas, storeProductsSearchParamsSchema as searchParamsSchema, selectShippingRateInputSchema, storeApiOrderSchema, updateCartItemInputSchema, updateCustomerInputSchema, updateCustomerSchema, wcErrorResponseSchema };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map