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

package/dist/index.js

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