@classytic/commerce-sdk 0.1.0

package/dist/server.d.ts

@@ -0,0 +1,120 @@
+export { configureSDK, getBaseUrl, getSDKConfig, handleApiRequest } from './core/index.js';
+import { a as authApi } from './user-data-DdLjAGwO.js';
+export { d as createUser, f as forgetPassApi, e as getProfile, g as getUser, c as getUserByPhone, l as loginApi, r as registerApi, b as resetPassApi, t as tokenRefreshApi, u as updateUser, v as verifyManagerAuth } from './user-data-DdLjAGwO.js';
+import { p as productApi, c as categoryApi, s as sizeGuideApi } from './size-guide-DgjzjM5P.js';
+import { M as cartApi, N as orderApi, Q as customerApi, V as posApi } from './pos-D1jkkFl0.js';
+import { t as transactionApi } from './transaction-u5oaNuav.js';
+import { c as couponApi, u as userApi, b as branchApi, p as platformConfigApi } from './coupon-CHFcw7cd.js';
+import { m as mediaApi, g as getCmsPage, u as updateCmsPage } from './media-CNLJK93J.js';
+import { p as paymentApi } from './payment-BRboLqvU.js';
+import { f as financeApi } from './finance-BJdfKRw0.js';
+import { l as logisticsApi } from './logistics-V8a9lUN3.js';
+import { s as stockApi, p as purchaseApi, t as transferApi, a as adjustmentApi, m as movementApi, r as requestApi, b as supplierApi } from './stock-DEApGC-w.js';
+export { a as analyticsApi } from './analytics-DMcD-o8w.js';
+import './api-factory-B_h4RKBm.js';
+import './product-p09zXkXB.js';
+import './inventory-DCiIZh8P.js';
+import './transaction-BTmoHpWh.js';
+
+/**
+ * @classytic/commerce-sdk - SDK Client Factory
+ *
+ * Create a configured SDK client instance for use in Next.js applications.
+ */
+
+declare const cmsApi: {
+    getPage: typeof getCmsPage;
+    updatePage: typeof updateCmsPage;
+};
+
+/**
+ * SDK Client Configuration Options
+ */
+interface CommerceSDKConfig {
+    /** Base URL for API requests (e.g., "https://api.example.com") */
+    baseUrl: string;
+    /** Default organization ID for multi-tenant support */
+    organizationId?: string;
+    /** Function to get current auth token */
+    getToken?: () => string | null | Promise<string | null>;
+    /** Default request cache mode */
+    cache?: RequestCache;
+    /** Default headers to include in all requests */
+    headers?: Record<string, string>;
+}
+/**
+ * Commerce SDK Client
+ *
+ * Provides typed access to all commerce APIs.
+ */
+interface CommerceSDKClient {
+    auth: typeof authApi;
+    product: typeof productApi;
+    category: typeof categoryApi;
+    sizeGuide: typeof sizeGuideApi;
+    cart: typeof cartApi;
+    order: typeof orderApi;
+    coupon: typeof couponApi;
+    customer: typeof customerApi;
+    user: typeof userApi;
+    branch: typeof branchApi;
+    media: typeof mediaApi;
+    payment: typeof paymentApi;
+    transaction: typeof transactionApi;
+    finance: typeof financeApi;
+    logistics: typeof logisticsApi;
+    platform: typeof platformConfigApi;
+    cms: typeof cmsApi;
+    pos: typeof posApi;
+    inventory: {
+        stock: typeof stockApi;
+        purchase: typeof purchaseApi;
+        transfer: typeof transferApi;
+        adjustment: typeof adjustmentApi;
+        movement: typeof movementApi;
+        request: typeof requestApi;
+        supplier: typeof supplierApi;
+    };
+}
+/**
+ * Create a configured Commerce SDK client
+ *
+ * @example
+ * ```typescript
+ * // In your app initialization
+ * import { createCommerceSDK } from '@classytic/commerce-sdk';
+ *
+ * const sdk = createCommerceSDK({
+ *   baseUrl: process.env.NEXT_PUBLIC_API_URL!,
+ *   getToken: () => getCookie('token'),
+ *   organizationId: 'org_123',
+ * });
+ *
+ * // Use the SDK
+ * const products = await sdk.product.getAll({ params: { page: 1 } });
+ * const order = await sdk.order.create({ token, data: orderData });
+ * ```
+ */
+declare function createCommerceSDK(config: CommerceSDKConfig): CommerceSDKClient;
+/**
+ * Initialize SDK configuration without creating a client
+ *
+ * Useful when you want to configure the SDK globally and use
+ * individual API instances directly.
+ *
+ * @example
+ * ```typescript
+ * import { initCommerceSDK, productApi } from '@classytic/commerce-sdk';
+ *
+ * // Initialize once at app startup
+ * initCommerceSDK({
+ *   baseUrl: process.env.NEXT_PUBLIC_API_URL!,
+ * });
+ *
+ * // Use APIs directly
+ * const products = await productApi.getAll({ params: { page: 1 } });
+ * ```
+ */
+declare function initCommerceSDK(config: CommerceSDKConfig): void;
+
+export { type CommerceSDKClient, type CommerceSDKConfig, adjustmentApi, authApi, branchApi, cartApi, categoryApi, couponApi, createCommerceSDK, customerApi, financeApi, getCmsPage, initCommerceSDK, logisticsApi, mediaApi, movementApi, orderApi, paymentApi, platformConfigApi, posApi, productApi, purchaseApi, requestApi, sizeGuideApi, stockApi, supplierApi, transactionApi, transferApi, updateCmsPage, userApi };

package/dist/server.js

@@ -0,0 +1,27 @@
+export { createCommerceSDK, initCommerceSDK } from './chunk-QUMTBLNE.js';
+export { logisticsApi } from './chunk-5L6EXDGH.js';
+export { financeApi } from './chunk-EIVYT3HM.js';
+export { transactionApi } from './chunk-5ZFW3FEI.js';
+export { getCmsPage, mediaApi, updateCmsPage } from './chunk-ZWLMFLLH.js';
+export { branchApi, couponApi, platformConfigApi, userApi } from './chunk-OF5M6R2S.js';
+export { paymentApi } from './chunk-ILQUH444.js';
+export { analyticsApi } from './chunk-4ZQK3FFN.js';
+export { authApi, createUser, forgetPassApi, getProfile, getUser, getUserByPhone, loginApi, registerApi, resetPassApi, tokenRefreshApi, updateUser, verifyManagerAuth } from './chunk-BDA2WSJA.js';
+export { categoryApi, productApi, sizeGuideApi } from './chunk-X6PV5MHG.js';
+import './chunk-PYYLHUV6.js';
+export { cartApi, customerApi, orderApi } from './chunk-UGELTUIZ.js';
+import './chunk-IXMWZJLV.js';
+export { purchaseApi } from './chunk-6RYGA6MF.js';
+export { transferApi } from './chunk-FA7QFJ2G.js';
+export { requestApi } from './chunk-QO5AGZFP.js';
+export { movementApi } from './chunk-SZYWG5IB.js';
+export { adjustmentApi } from './chunk-R5Z7NYLH.js';
+export { supplierApi } from './chunk-WUOQK7BO.js';
+export { stockApi } from './chunk-KZIGRIQG.js';
+export { posApi } from './chunk-66OQAZSL.js';
+import './chunk-I5TIKUIQ.js';
+import './chunk-B6MPVOV7.js';
+import './chunk-U3XT35GZ.js';
+export { configureSDK, getBaseUrl, getSDKConfig, handleApiRequest } from './chunk-VR36QVX2.js';
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"server.js"}

package/dist/size-guide-DgjzjM5P.d.ts

@@ -0,0 +1,554 @@
+import { B as BaseApi, A as ApiResponse, P as PaginatedResponse } from './api-factory-B_h4RKBm.js';
+import { e as Product, C as CreateProductPayload, U as UpdateProductPayload, i as ProductSyncStockResponse } from './product-p09zXkXB.js';
+
+/**
+ * Category Types
+ *
+ * Source of truth: modules/commerce/category/category.model.js
+ *
+ * **Slug-Based Design:**
+ * - Products store `category` as slug string (not ObjectId)
+ * - Enables fast queries without $lookup/aggregation
+ * - Example: `db.products.find({ category: "electronics" })`
+ *
+ * **Product Count:**
+ * - Automatically maintained via product repository events
+ * - Increments on product create
+ * - Decrements on product delete
+ * - Updates when product changes category
+ */
+interface CategoryImage {
+    url?: string;
+    alt?: string;
+}
+interface CategorySeo {
+    title?: string;
+    description?: string;
+    keywords?: string[];
+}
+interface Category {
+    _id: string;
+    /** Display name (can be changed without breaking product references) */
+    name: string;
+    /**
+     * URL-safe identifier (auto-generated from name, globally unique).
+     * Products store this value in their `category` field.
+     * IMMUTABLE after creation.
+     */
+    slug: string;
+    /**
+     * Parent category slug (not ObjectId).
+     * null for root categories.
+     */
+    parent: string | null;
+    /** Short description for category listing */
+    description?: string;
+    /** Category image for display */
+    image?: CategoryImage;
+    /** Display order for sorting (lower = first) */
+    displayOrder: number;
+    /**
+     * Category-specific VAT rate override.
+     * null = use platform default rate.
+     */
+    vatRate?: number | null;
+    /** Whether category is visible to customers */
+    isActive: boolean;
+    /**
+     * Cached product count (maintained by product repository events).
+     * Updated automatically on product create/delete/category-change.
+     */
+    productCount: number;
+    /** SEO metadata */
+    seo?: CategorySeo;
+    createdAt: string;
+    updatedAt: string;
+    /** Full path e.g. "clothing/t-shirts" */
+    fullPath?: string;
+    /** Whether this is a root category (no parent) */
+    isRoot?: boolean;
+}
+/**
+ * Category with nested children for tree display
+ * Used for navigation menus and admin selects
+ *
+ * **To flatten for dropdowns:**
+ * ```typescript
+ * function flattenTree(nodes, depth = 0, result = []) {
+ *   for (const n of nodes) {
+ *     result.push({ ...n, depth, displayName: '  '.repeat(depth) + n.name });
+ *     if (n.children) flattenTree(n.children, depth + 1, result);
+ *   }
+ *   return result;
+ * }
+ * ```
+ */
+interface CategoryTreeNode extends Category {
+    /** Child categories (empty array for leaf nodes) */
+    children?: CategoryTreeNode[];
+}
+interface CreateCategoryPayload {
+    /** Required: Display name (slug auto-generated from this) */
+    name: string;
+    /** Parent category slug (not ObjectId) */
+    parent?: string;
+    /** Short description */
+    description?: string;
+    /** Category image */
+    image?: CategoryImage;
+    /** Display order (lower = first, default: 0) */
+    displayOrder?: number;
+    /** VAT rate override (null = use platform default) */
+    vatRate?: number | null;
+    /** Whether visible to customers (default: true) */
+    isActive?: boolean;
+    /** SEO metadata */
+    seo?: CategorySeo;
+}
+interface UpdateCategoryPayload {
+    /** Display name (slug is immutable, cannot be changed) */
+    name?: string;
+    /** Short description */
+    description?: string;
+    /** Category image */
+    image?: CategoryImage;
+    /** Display order */
+    displayOrder?: number;
+    /** VAT rate override */
+    vatRate?: number | null;
+    /** Visibility */
+    isActive?: boolean;
+    /** SEO metadata */
+    seo?: CategorySeo;
+}
+/**
+ * Response from GET /categories (paginated list)
+ */
+interface CategoryListResponse {
+    success: boolean;
+    method: "offset";
+    docs: Category[];
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+}
+/**
+ * Response from GET /categories/tree
+ */
+interface CategoryTreeResponse {
+    success: boolean;
+    data: CategoryTreeNode[];
+}
+/**
+ * Response from GET /categories/:id or /categories/slug/:slug
+ */
+interface CategoryResponse {
+    success: boolean;
+    data: Category;
+}
+/**
+ * Response from DELETE /categories/:id
+ */
+interface CategoryDeleteResponse {
+    success: boolean;
+    deleted: boolean;
+    message?: string;
+}
+/**
+ * Response from POST /categories/sync-product-count
+ */
+interface CategorySyncResponse {
+    success: boolean;
+    data: {
+        updated: number;
+    };
+}
+
+/**
+ * Size Guide Types
+ *
+ * Size guides are templates that can be referenced by products to display size information.
+ * Products store `sizeGuideSlug` to reference a size guide.
+ *
+ * **Dynamic Measurements:**
+ * - `measurementLabels` define the columns (e.g., ["Chest", "Length", "Shoulder"])
+ * - Each size has a `measurements` object with key-value pairs
+ * - Keys are lowercase/underscored versions of labels (e.g., "chest", "length")
+ */
+interface SizeDefinition {
+    /** Size name (e.g., "XS", "S", "M", "L", "XL") */
+    name: string;
+    /**
+     * Key-value pairs of measurements.
+     * Keys should match measurementLabels (lowercase, underscored).
+     * Values are strings to support ranges (e.g., "34-36").
+     */
+    measurements: Record<string, string>;
+}
+interface SizeGuide {
+    _id: string;
+    /** Size guide name (e.g., "T-Shirts & Tops") */
+    name: string;
+    /**
+     * URL-safe identifier (auto-generated from name, globally unique).
+     * Products store this value in their `sizeGuideSlug` field.
+     */
+    slug: string;
+    /** Size guide description (max 500 chars) */
+    description?: string;
+    /** Measurement unit: 'inches' or 'cm' */
+    measurementUnit: 'inches' | 'cm';
+    /**
+     * Array of measurement labels (e.g., ["Chest", "Length", "Shoulder", "Sleeve"]).
+     * Used as table column headers. Max 10 labels.
+     */
+    measurementLabels: string[];
+    /** Array of size definitions with measurements */
+    sizes: SizeDefinition[];
+    /** Additional notes for customers (max 1000 chars) */
+    note?: string;
+    /** Whether size guide is visible to customers */
+    isActive: boolean;
+    /** Display order for sorting (lower = first) */
+    displayOrder: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateSizeGuidePayload {
+    /** Required: Size guide name (slug auto-generated from this) */
+    name: string;
+    /** Custom slug (optional, auto-generated if not provided) */
+    slug?: string;
+    /** Size guide description */
+    description?: string;
+    /** Measurement unit (default: 'inches') */
+    measurementUnit?: 'inches' | 'cm';
+    /** Measurement labels (max 10) */
+    measurementLabels?: string[];
+    /** Size definitions */
+    sizes?: SizeDefinition[];
+    /** Additional notes */
+    note?: string;
+    /** Whether visible to customers (default: true) */
+    isActive?: boolean;
+    /** Display order (default: 0) */
+    displayOrder?: number;
+}
+interface UpdateSizeGuidePayload {
+    /** Size guide name */
+    name?: string;
+    /** Size guide description */
+    description?: string;
+    /** Measurement unit */
+    measurementUnit?: 'inches' | 'cm';
+    /** Measurement labels (replaces existing) */
+    measurementLabels?: string[];
+    /** Size definitions (replaces existing) */
+    sizes?: SizeDefinition[];
+    /** Additional notes */
+    note?: string;
+    /** Visibility */
+    isActive?: boolean;
+    /** Display order */
+    displayOrder?: number;
+}
+/**
+ * Response from GET /size-guides (paginated list)
+ */
+interface SizeGuideListResponse {
+    success: boolean;
+    docs: SizeGuide[];
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+}
+/**
+ * Response from GET /size-guides/:id or /size-guides/slug/:slug
+ */
+interface SizeGuideResponse {
+    success: boolean;
+    data: SizeGuide;
+}
+/**
+ * Response from DELETE /size-guides/:id
+ */
+interface SizeGuideDeleteResponse {
+    success: boolean;
+    message?: string;
+}
+
+/**
+ * Product API Client
+ *
+ * **Authentication:**
+ * - Public: List, Get, GetBySlug, GetRecommendations
+ * - Admin: Create, Update, Delete, GetDeleted, Restore, HardDelete, SyncStock
+ *
+ * **Base URL:** `/api/v1/products`
+ */
+
+type FetchOptions$2 = {
+    cache?: RequestCache;
+    revalidate?: number;
+    tags?: string[];
+};
+/**
+ * Product API Client
+ * Extends BaseApi with product-specific endpoints
+ */
+declare class ProductApi extends BaseApi<Product, CreateProductPayload, UpdateProductPayload> {
+    constructor(config?: {});
+    /**
+     * Get product by slug
+     * GET /products/slug/:slug
+     * (Public endpoint)
+     *
+     * @param token - Auth token (optional, public endpoint)
+     * @param slug - Product slug
+     * @param options - Additional fetch options
+     * @returns Product object
+     */
+    getBySlug({ token, slug, options, }: {
+        token?: string | null;
+        slug: string;
+        options?: FetchOptions$2;
+    }): Promise<ApiResponse<Product>>;
+    /**
+     * Get product recommendations
+     * GET /products/:id/recommendations
+     * (Public endpoint)
+     *
+     * @param token - Auth token (optional)
+     * @param productId - Product ID to get recommendations for
+     * @param options - Additional fetch options
+     * @returns List of recommended products
+     */
+    getRecommendations({ token, productId, options, }: {
+        token?: string | null;
+        productId: string;
+        options?: FetchOptions$2;
+    }): Promise<ApiResponse<Product[]>>;
+    /**
+     * Get soft-deleted products (Recycle Bin)
+     * GET /products/deleted
+     * (Admin only)
+     *
+     * @param token - Auth token (required)
+     * @param params - Query parameters for pagination/filtering
+     * @param options - Additional fetch options
+     * @returns Paginated list of deleted products
+     */
+    getDeleted({ token, params, options, }: {
+        token: string;
+        params?: Record<string, unknown>;
+        options?: FetchOptions$2;
+    }): Promise<PaginatedResponse<Product>>;
+    /**
+     * Restore a soft-deleted product
+     * POST /products/:id/restore
+     * (Admin only)
+     *
+     * @param token - Auth token (required)
+     * @param id - Product ID to restore
+     * @param options - Additional fetch options
+     * @returns Restored product
+     */
+    restore({ token, id, options, }: {
+        token: string;
+        id: string;
+        options?: FetchOptions$2;
+    }): Promise<ApiResponse<Product>>;
+    /**
+     * Permanently delete a product (Hard delete)
+     * DELETE /products/:id?hard=true
+     * (Admin only - use with caution)
+     *
+     * @param token - Auth token (required)
+     * @param id - Product ID to permanently delete
+     * @param options - Additional fetch options
+     * @returns Delete confirmation
+     */
+    hardDelete({ token, id, options, }: {
+        token: string;
+        id: string;
+        options?: FetchOptions$2;
+    }): Promise<ApiResponse<{
+        deleted: boolean;
+    }>>;
+    /**
+     * Sync product stock quantity
+     * POST /products/:id/sync-stock
+     *
+     * Recomputes product.quantity by summing all StockEntry quantities across branches.
+     * (Requires: admin, warehouse-admin, warehouse-staff, or store-manager role)
+     *
+     * @param token - Auth token (required)
+     * @param id - Product ID to sync stock for
+     * @param options - Additional fetch options
+     * @returns Sync result with new quantity
+     */
+    syncStock({ token, id, options, }: {
+        token: string;
+        id: string;
+        options?: FetchOptions$2;
+    }): Promise<ProductSyncStockResponse>;
+}
+declare const productApi: ProductApi;
+
+/**
+ * Category API Client
+ *
+ * **Authentication:**
+ * - Public: List, Get, Tree, GetBySlug
+ * - Admin: Create, Update, Delete
+ *
+ * **Base URL:** `/api/v1/categories`
+ *
+ * **Slug-Based Design:**
+ * - Categories use slugs as identifiers (not ObjectIds)
+ * - Products store category as slug string for fast queries
+ * - Example: `db.products.find({ category: "electronics" })`
+ */
+
+type FetchOptions$1 = {
+    cache?: RequestCache;
+    revalidate?: number;
+    tags?: string[];
+};
+/**
+ * Category API Client
+ * Extends BaseApi with category-specific endpoints
+ */
+declare class CategoryApi extends BaseApi<Category, CreateCategoryPayload, UpdateCategoryPayload> {
+    constructor(config?: {});
+    /**
+     * Get category tree (nested structure)
+     * GET /categories/tree
+     *
+     * **This is the main endpoint - FE should cache this and derive everything else from it.**
+     *
+     * Returns nested tree structure with children. Use helper functions to flatten, search, or extract children.
+     *
+     * @param token - Auth token (optional, public endpoint)
+     * @param options - Additional fetch options
+     * @returns Nested category tree
+     *
+     * @example
+     * ```typescript
+     * const { data } = await categoryApi.getTree({ token: null });
+     * // data = [{ slug: "clothing", name: "Clothing", children: [...] }]
+     * ```
+     */
+    getTree({ token, options, }?: {
+        token?: string | null;
+        options?: FetchOptions$1;
+    }): Promise<CategoryTreeResponse>;
+    /**
+     * Get category by slug
+     * GET /categories/slug/:slug
+     *
+     * For URL resolution when you need full category details.
+     *
+     * @param token - Auth token (optional, public endpoint)
+     * @param slug - Category slug (e.g., "electronics", "t-shirts")
+     * @param options - Additional fetch options
+     * @returns Category object
+     *
+     * @example
+     * ```typescript
+     * const { data } = await categoryApi.getBySlug({
+     *   token: null,
+     *   slug: 'electronics'
+     * });
+     * ```
+     */
+    getBySlug({ token, slug, options, }: {
+        token?: string | null;
+        slug: string;
+        options?: FetchOptions$1;
+    }): Promise<ApiResponse<Category>>;
+    /**
+     * Sync product counts for all categories
+     * POST /categories/sync-product-count
+     *
+     * Recalculates `productCount` for all categories based on current products.
+     * Use when manual data fixes or migrations may have desynced counts.
+     *
+     * @param token - Auth token (admin or inventory staff required)
+     * @param options - Additional fetch options
+     * @returns Number of categories updated
+     *
+     * @example
+     * ```typescript
+     * const { data } = await categoryApi.syncProductCount({ token });
+     * // data = { updated: 42 }
+     * ```
+     */
+    syncProductCount({ token, options, }: {
+        token: string;
+        options?: FetchOptions$1;
+    }): Promise<ApiResponse<{
+        updated: number;
+    }>>;
+}
+declare const categoryApi: CategoryApi;
+
+/**
+ * Size Guide API Client
+ *
+ * **Authentication:**
+ * - Public: List, Get, GetBySlug
+ * - Admin: Create, Update, Delete
+ *
+ * **Base URL:** `/api/v1/size-guides`
+ *
+ * **Slug-Based Design:**
+ * - Size guides use slugs as identifiers
+ * - Products store `sizeGuideSlug` to reference a size guide
+ */
+
+type FetchOptions = {
+    cache?: RequestCache;
+    revalidate?: number;
+    tags?: string[];
+};
+/**
+ * Size Guide API Client
+ * Extends BaseApi with size-guide-specific endpoints
+ */
+declare class SizeGuideApi extends BaseApi<SizeGuide, CreateSizeGuidePayload, UpdateSizeGuidePayload> {
+    constructor(config?: {});
+    /**
+     * Get size guide by slug
+     * GET /size-guides/slug/:slug
+     *
+     * For product detail pages to fetch the appropriate size guide.
+     *
+     * @param token - Auth token (optional, public endpoint)
+     * @param slug - Size guide slug (e.g., "t-shirts-tops")
+     * @param options - Additional fetch options
+     * @returns Size guide object
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sizeGuideApi.getBySlug({
+     *   token: null,
+     *   slug: 't-shirts-tops'
+     * });
+     * ```
+     */
+    getBySlug({ token, slug, options, }: {
+        token?: string | null;
+        slug: string;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<SizeGuide>>;
+}
+declare const sizeGuideApi: SizeGuideApi;
+
+export { CategoryApi as C, ProductApi as P, SizeGuideApi as S, type UpdateCategoryPayload as U, type CategoryImage as a, type CategorySeo as b, categoryApi as c, type Category as d, type CategoryTreeNode as e, type CreateCategoryPayload as f, type CategoryListResponse as g, type CategoryTreeResponse as h, type CategoryResponse as i, type CategoryDeleteResponse as j, type CategorySyncResponse as k, type SizeDefinition as l, type SizeGuide as m, type CreateSizeGuidePayload as n, type UpdateSizeGuidePayload as o, productApi as p, type SizeGuideListResponse as q, type SizeGuideResponse as r, sizeGuideApi as s, type SizeGuideDeleteResponse as t };