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

package/dist/index.js

@@ -1,7 +1,9 @@
 '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 }; }
 
@@ -449,9 +451,9 @@ var setupRequestInterceptor = (axiosInstance, config, client) => {
   axiosInstance.interceptors.request.use(
     async (requestConfig) => {
       const url = requestConfig.url;
-      if (requiresAuth(url) && config.jwtToken) {
+      if (config.jwtToken) {
         const token = await config.jwtToken.get();
-        if (token) {
+        if (token && (requiresAuth(url) || requiresCartAuth(url))) {
           requestConfig.headers.Authorization = `Bearer ${token}`;
           if (config.debug) {
             debug("Injected JWT token for", url);
@@ -460,10 +462,11 @@ var setupRequestInterceptor = (axiosInstance, config, client) => {
       }
       if (requiresCartAuth(url)) {
         const headers = await config.cartHeaders.get();
+        const isAuthenticated = !!await config.jwtToken?.get();
         if (headers.nonce) {
           requestConfig.headers.Nonce = headers.nonce;
         }
-        if (headers.cartToken) {
+        if (headers.cartToken && !isAuthenticated) {
           requestConfig.headers["Cart-Token"] = headers.cartToken;
         }
         requestConfig.headers["Cache-Control"] = "no-cache, no-store, must-revalidate";
@@ -631,861 +634,50 @@ 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);
-
-// src/schemas/store-api/cart-item.schema.ts
-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)
-});
-
-// src/schemas/store-api/cart.ts
-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()
-});
-
-// src/schemas/store-api/order.schema.ts
-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()
-});
-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()
-});
-
-// src/schemas/store-api/products.ts
-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())
-});
-
-// src/api/cart.ts
 var createCartAPI = (client, endpoints, options) => ({
   get: async () => {
     const response = await client.get(endpoints.cart);
-    return handleApiResponse(response, cartSchema, options);
+    return handleApiResponse(response, storeApi.cartSchema, options);
   },
   addItem: async (input) => {
     const response = await client.post(endpoints.addItem, input);
-    return handleApiResponse(response, cartSchema, options);
+    return handleApiResponse(response, storeApi.cartSchema, options);
   },
   updateItem: async (input) => {
     const response = await client.post(endpoints.updateItem, input);
-    return handleApiResponse(response, cartSchema, options);
+    return handleApiResponse(response, storeApi.cartSchema, options);
   },
   removeItem: async (input) => {
     const response = await client.post(endpoints.removeItem, input);
-    return handleApiResponse(response, cartSchema, options);
+    return handleApiResponse(response, storeApi.cartSchema, options);
   },
   applyCoupon: async (input) => {
     const response = await client.post(endpoints.applyCoupon, input);
-    return handleApiResponse(response, cartSchema, options);
+    return handleApiResponse(response, storeApi.cartSchema, options);
   },
   removeCoupon: async (input) => {
     const response = await client.post(endpoints.removeCoupon, input);
-    return handleApiResponse(response, cartSchema, options);
+    return handleApiResponse(response, storeApi.cartSchema, options);
   },
   updateCustomer: async (input) => {
     const response = await client.post(endpoints.updateCustomer, input);
-    return handleApiResponse(response, cartSchema, options);
+    return handleApiResponse(response, storeApi.cartSchema, options);
   },
   selectShippingRate: async (input) => {
     const response = await client.post(endpoints.selectShippingRate, input);
-    return handleApiResponse(response, cartSchema, options);
+    return handleApiResponse(response, storeApi.cartSchema, options);
   }
 });
-
-// src/api/checkout.ts
 var createCheckoutAPI = (client, endpoints, options) => ({
   get: async () => {
     const response = await client.get(endpoints.checkout);
-    return handleApiResponse(response, checkoutSchema, options);
+    return handleApiResponse(response, storeApi.checkoutSchema, options);
   },
   process: async (input) => {
     const response = await client.post(endpoints.checkout, input);
-    return handleApiResponse(response, checkoutSchema, options);
+    return handleApiResponse(response, storeApi.checkoutSchema, options);
   }
 });
-
-// src/api/orders.ts
 var createOrdersAPI = (client, endpoints, options) => ({
   /**
    * Get a single order by ID
@@ -1495,21 +687,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, storeApiOrderSchema, options);
+    return handleApiResponse(response, storeApi.storeApiOrderSchema, options);
   }
 });
 var createProductsAPI = (client, endpoints, options) => ({
   list: async (params) => {
     const response = await client.get(endpoints.products, { params });
-    return handlePaginatedApiResponse(response, zod.z.array(productSchema), params, options);
+    return handlePaginatedApiResponse(response, zod.z.array(storeApi.productSchema), params, options);
   },
   get: async (id) => {
     const response = await client.get(`${endpoints.products}/${id}`);
-    return handleApiResponse(response, productSchema, options);
+    return handleApiResponse(response, storeApi.productSchema, options);
   },
   categories: async () => {
     const response = await client.get(endpoints.categories);
-    return handleApiResponse(response, zod.z.array(productCategorySchema), options);
+    return handleApiResponse(response, zod.z.array(storeApi.productCategorySchema), options);
   }
 });
 
@@ -1575,578 +767,164 @@ var createClient = (config) => {
   return client;
 };
 
-// src/schemas/admin-api/enums/enums-raw.ts
-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
-  }
-};
-
-// src/schemas/admin-api/enums/enums.ts
-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, "addToCartInputSchema", {
+  enumerable: true,
+  get: function () { return storeApi.addToCartInputSchema; }
 });
-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, "addressSchema", {
+  enumerable: true,
+  get: function () { return storeApi.addressSchema; }
 });
-zod.z.object({
-  status: zod.z.enum(["publish", "future", "draft", "pending", "private"]).optional()
+Object.defineProperty(exports, "billingAddressSchema", {
+  enumerable: true,
+  get: function () { return storeApi.billingAddressSchemaMandatory; }
 });
-zod.z.object({
-  "x-wp-total": zod.z.string().transform(Number),
-  "x-wp-totalpages": zod.z.string().transform(Number)
+Object.defineProperty(exports, "cartItemImageSchema", {
+  enumerable: true,
+  get: function () { return storeApi.cartItemImageSchema; }
 });
-zod.z.object({
-  ...basePaginationSchema.shape,
-  ...baseFilteringSchema.shape,
-  context: zod.z.enum(["view", "edit"]).default("view")
+Object.defineProperty(exports, "cartSchema", {
+  enumerable: true,
+  get: function () { return storeApi.cartSchema; }
 });
-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, "checkoutInputSchema", {
+  enumerable: true,
+  get: function () { return storeApi.checkoutInputSchema; }
 });
-
-// src/schemas/admin-api/base/base-wc.schema.ts
-var wcSortingSchema = zod.z.object({
-  order: getAppEnumZod("COMMON_SORT_ORDER").default("desc"),
-  orderby: zod.z.string().optional()
+Object.defineProperty(exports, "checkoutSchema", {
+  enumerable: true,
+  get: function () { return storeApi.checkoutSchema; }
 });
-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, "couponInputSchema", {
+  enumerable: true,
+  get: function () { return storeApi.couponInputSchema; }
 });
-var wcMetaDataSchema = zod.z.object({
-  id: zod.z.number(),
-  key: zod.z.string(),
-  value: zod.z.any()
+Object.defineProperty(exports, "paginationMetaSchema", {
+  enumerable: true,
+  get: function () { return storeApi.paginationMetaSchema; }
 });
-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, "paginationParamsSchema", {
+  enumerable: true,
+  get: function () { return storeApi.paginationParamsSchema; }
 });
-var wcBaseParamsSchema = zod.z.object({
-  ...basePaginationSchema.shape,
-  ...baseFilteringSchema.shape,
-  ...wcSortingSchema.shape
+Object.defineProperty(exports, "productCategorySchema", {
+  enumerable: true,
+  get: function () { return storeApi.productCategorySchema; }
 });
-var wcBaseResponseSchema = zod.z.object({
-  _links: wpLinksSchema,
-  meta_data: zod.z.array(wcMetaDataSchema).optional()
+Object.defineProperty(exports, "productImageSchema", {
+  enumerable: true,
+  get: function () { return storeApi.productImageSchema; }
 });
-zod.z.object({
-  total: zod.z.number(),
-  totalPages: zod.z.number(),
-  currentPage: zod.z.number(),
-  perPage: zod.z.number()
+Object.defineProperty(exports, "productSchema", {
+  enumerable: true,
+  get: function () { return storeApi.productSchema; }
 });
-var wcErrorResponseSchema = zod.z.object({
-  code: getAppEnumZod("COMMON_ERROR_CODES"),
-  message: zod.z.string(),
-  data: zod.z.object({
-    status: zod.z.number()
-  }).optional()
-}).passthrough();
-
-// src/schemas/admin-api/coupons/coupon-filter.schema.ts
-var couponFilterSchema = wcBaseParamsSchema.extend({
-  orderby: getAppEnumZod("COUPONS_ORDER_BY").default("date"),
-  code: zod.z.string().optional()
+Object.defineProperty(exports, "removeCartItemInputSchema", {
+  enumerable: true,
+  get: function () { return storeApi.removeCartItemInputSchema; }
 });
-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, "searchParamsSchema", {
+  enumerable: true,
+  get: function () { return storeApi.searchParamsSchema; }
 });
-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, "selectShippingRateInputSchema", {
+  enumerable: true,
+  get: function () { return storeApi.selectShippingRateInputSchema; }
 });
-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, "storeApiOrderSchema", {
+  enumerable: true,
+  get: function () { return storeApi.storeApiOrderSchema; }
 });
-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, "updateCartItemInputSchema", {
+  enumerable: true,
+  get: function () { return storeApi.updateCartItemInputSchema; }
 });
-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, "updateCustomerInputSchema", {
+  enumerable: true,
+  get: function () { return storeApi.updateCustomerInputSchema; }
 });
-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, "adminCategoryFilterSchema", {
+  enumerable: true,
+  get: function () { return adminApi.categoryFilterSchema; }
 });
-var orderSchema = 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, "adminCouponFilterSchema", {
+  enumerable: true,
+  get: function () { return adminApi.couponFilterSchema; }
 });
-var paymentMethodFilterSchema = wcBaseParamsSchema.extend({
-  enabled: zod.z.boolean().optional()
+Object.defineProperty(exports, "adminCouponSchema", {
+  enumerable: true,
+  get: function () { return adminApi.couponSchema; }
 });
-var paymentMethodSchema = 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, "adminOrderFilterSchema", {
+  enumerable: true,
+  get: function () { return adminApi.orderFilterSchema; }
 });
-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, "adminOrderSchema", {
+  enumerable: true,
+  get: function () { return adminApi.orderSchema; }
 });
-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, "adminProductCategorySchema", {
+  enumerable: true,
+  get: function () { return adminApi.productCategorySchema; }
 });
-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, "adminProductFilterSchema", {
+  enumerable: true,
+  get: function () { return adminApi.productFilterSchema; }
 });
-
-// src/schemas/admin-api/products/category.schema.ts
-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, "adminProductSchema", {
+  enumerable: true,
+  get: function () { return adminApi.productSchema; }
 });
-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")
+Object.defineProperty(exports, "createCategorySchema", {
+  enumerable: true,
+  get: function () { return adminApi.createCategorySchema; }
+});
+Object.defineProperty(exports, "createCouponSchema", {
+  enumerable: true,
+  get: function () { return adminApi.createCouponSchema; }
+});
+Object.defineProperty(exports, "createCustomerSchema", {
+  enumerable: true,
+  get: function () { return adminApi.createCustomerSchema; }
+});
+Object.defineProperty(exports, "customerFilterSchema", {
+  enumerable: true,
+  get: function () { return adminApi.customerFilterSchema; }
+});
+Object.defineProperty(exports, "customerSchema", {
+  enumerable: true,
+  get: function () { return adminApi.customerSchema; }
+});
+Object.defineProperty(exports, "getAppEnumRaw", {
+  enumerable: true,
+  get: function () { return adminApi.getAppEnumRaw; }
+});
+Object.defineProperty(exports, "getAppEnumZod", {
+  enumerable: true,
+  get: function () { return adminApi.getAppEnumZod; }
+});
+Object.defineProperty(exports, "paymentMethodFilterSchema", {
+  enumerable: true,
+  get: function () { return adminApi.paymentMethodFilterSchema; }
+});
+Object.defineProperty(exports, "paymentMethodSchema", {
+  enumerable: true,
+  get: function () { return adminApi.paymentMethodSchema; }
+});
+Object.defineProperty(exports, "schemas", {
+  enumerable: true,
+  get: function () { return adminApi.schemas; }
+});
+Object.defineProperty(exports, "updateCustomerSchema", {
+  enumerable: true,
+  get: function () { return adminApi.updateCustomerSchema; }
+});
+Object.defineProperty(exports, "wcErrorResponseSchema", {
+  enumerable: true,
+  get: function () { return adminApi.wcErrorResponseSchema; }
 });
-
-// src/schemas/admin-api/index.ts
-var schemas = {
-  resources: {
-    product: {
-      filter: productFilterSchema,
-      entity: productSchema2,
-      category: {
-        filter: categoryFilterSchema,
-        entity: productCategorySchema2
-      }
-    },
-    order: {
-      filter: orderFilterSchema,
-      entity: orderSchema,
-      lineItem: orderLineItemSchema
-    },
-    customer: {
-      filter: customerFilterSchema,
-      entity: customerSchema,
-      create: createCustomerSchema,
-      update: updateCustomerSchema
-    },
-    coupon: {
-      filter: couponFilterSchema,
-      entity: couponSchema,
-      create: createCouponSchema
-    },
-    paymentMethod: {
-      filter: paymentMethodFilterSchema,
-      entity: paymentMethodSchema
-    }
-  }
-};
-
 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 = orderSchema;
-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 = paymentMethodSchema;
-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