@classytic/commerce-sdk 0.1.1

package/dist/sales/index.d.ts

@@ -0,0 +1,587 @@
+import { C as Cart, a as CartItem, A as AddCartItemPayload, U as UpdateCartItemPayload, f as Customer, j as CustomerPayload } from '../pos-BCqkx2-K.js';
+export { c as AddToCartPayload, e as CartItemVariation, d as CartResponse, b as CartSummary, g as CustomerAddress, s as CustomerApi, n as CustomerGender, l as CustomerListResponse, i as CustomerMembership, k as CustomerQueryParams, m as CustomerResponse, h as CustomerStats, o as CustomerTier, P as PopulatedCartItem, R as RemoveCartItemPayload, p as cartApi, r as customerApi, q as orderApi, q as orderApiDefault, t as posApi, t as posApiDefault } from '../pos-BCqkx2-K.js';
+import { b as Order, l as CreateOrderPayload, F as FulfillOrderPayload, o as RequestShippingPayload, h as OrderShipping, p as UpdateShippingPayload } from '../order-B3dCvHgK.js';
+export { m as CancelOrderPayload, n as CancelRequestPayload, C as CancellationRequest, e as OrderAddress, d as OrderDelivery, c as OrderItem, j as OrderParcel, g as OrderPayment, i as OrderShippingHistory, O as OrderStatus, f as OrderVat, k as PaymentData, P as PaymentStatus, R as RefundOrderPayload, a as ShippingProvider, S as ShippingStatus, U as UpdateStatusPayload } from '../order-B3dCvHgK.js';
+import { P as PosProduct, a as PosProductsResponse, g as PosLookupResponse, q as PosReceiptResponse, l as PosOrderPayload, ac as CreateAdjustmentPayload, ad as BulkAdjustmentPayload } from '../inventory-B5pssqRx.js';
+export { B as BranchStock, t as PaymentOption, u as PaymentState, s as PosCartItem, k as PosCustomer, f as PosLookupData, e as PosLookupProduct, h as PosLookupResult, i as PosOrderItem, j as PosPayment, m as PosPaymentMethod, c as PosProductsBranch, d as PosProductsParams, b as PosProductsSummary, r as PosReceipt, p as PosReceiptData, n as PosReceiptItem, o as PosReceiptVat, S as SplitPaymentEntry, V as VariantStock } from '../inventory-B5pssqRx.js';
+import { b as ProductVariant } from '../product-p09zXkXB.js';
+import { k as QueryKeys, b as CrudHooksReturn, L as ListOptions, l as ListQueryResult, D as DetailOptions, m as DetailQueryResult, d as CrudActions, N as NavigateFn } from '../crud.factory-DyKaPHcU.js';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import '../api-factory-B_h4RKBm.js';
+
+declare const CART_KEYS: QueryKeys;
+/**
+ * Calculate unit price for a cart item
+ * Handles both simple products and variant products
+ */
+declare function calculateItemPrice(item: CartItem): number;
+/**
+ * Calculate total for a cart item
+ */
+declare function calculateItemTotal(item: CartItem): number;
+/**
+ * Calculate cart subtotal
+ */
+declare function calculateCartSubtotal(items: CartItem[]): number;
+/**
+ * Get total item count in cart
+ */
+declare function getCartItemCount(items: CartItem[]): number;
+/**
+ * Get variant details from a cart item
+ */
+declare function getCartItemVariant(item: CartItem): ProductVariant | null;
+/**
+ * Format variant attributes for display
+ * @example "Size: M, Color: Red"
+ */
+declare function formatVariantAttributes(attributes?: Record<string, string> | null): string;
+interface UseCartReturn {
+    cart: Cart | null | undefined;
+    items: CartItem[];
+    itemCount: number;
+    subtotal: number;
+    isLoading: boolean;
+    isFetching: boolean;
+    isUpdating: boolean;
+    error: Error | null;
+    addToCart: (data: AddCartItemPayload) => void;
+    addToCartAsync: (data: AddCartItemPayload) => Promise<Cart>;
+    updateCartItem: (data: UpdateCartItemPayload) => void;
+    updateCartItemAsync: (data: UpdateCartItemPayload) => Promise<Cart>;
+    removeCartItem: (itemId: string) => void;
+    removeCartItemAsync: (itemId: string) => Promise<Cart>;
+    clearCart: () => void;
+    clearCartAsync: () => Promise<Cart>;
+    refetch: () => void;
+    getItemPrice: typeof calculateItemPrice;
+}
+interface UseCartCountReturn {
+    count: number;
+    isLoading: boolean;
+}
+interface CartOptions {
+    enabled?: boolean;
+    staleTime?: number;
+    gcTime?: number;
+}
+/**
+ * Full cart hook with optimistic updates
+ *
+ * @example
+ * ```tsx
+ * function CartPage() {
+ *   const {
+ *     items,
+ *     itemCount,
+ *     subtotal,
+ *     addToCart,
+ *     updateCartItem,
+ *     removeCartItem,
+ *     clearCart,
+ *     isLoading,
+ *     isUpdating,
+ *   } = useCart(token);
+ *
+ *   // Add item
+ *   addToCart({ productId: "123", quantity: 2 });
+ *
+ *   // Add variant item
+ *   addToCart({ productId: "123", variantSku: "SIZE-M", quantity: 1 });
+ *
+ *   // Update quantity
+ *   updateCartItem({ itemId: "item_id", quantity: 3 });
+ *
+ *   // Remove item
+ *   removeCartItem("item_id");
+ *
+ *   // Clear cart
+ *   clearCart();
+ * }
+ * ```
+ */
+declare function useCart(token: string | null | undefined, options?: CartOptions): UseCartReturn;
+/**
+ * Lightweight hook for cart count (header badge)
+ *
+ * @example
+ * ```tsx
+ * function CartBadge() {
+ *   const { count, isLoading } = useCartCount(token);
+ *   return <Badge>{isLoading ? "..." : count}</Badge>;
+ * }
+ * ```
+ */
+declare function useCartCount(token: string | null | undefined, options?: CartOptions): UseCartCountReturn;
+
+/**
+ * Order hooks using createCrudHooks factory
+ *
+ * Provides:
+ * - useOrders: List orders with filtering/pagination
+ * - useOrderDetail: Get single order
+ * - useOrderActions: Create, update, delete mutations
+ * - useOrderNavigation: Navigation between orders
+ */
+declare const orderHooks: CrudHooksReturn<Order, CreateOrderPayload, Partial<Order>>;
+declare const ORDER_KEYS: {
+    all: readonly ["orders"];
+    lists: () => readonly ["orders", "list"];
+    list: (params?: Record<string, unknown>) => readonly ["orders", "list", Record<string, unknown> | undefined];
+    details: () => readonly ["orders", "detail"];
+    detail: (id: string) => readonly ["orders", "detail", string];
+    myOrders: (params?: Record<string, unknown>) => readonly ["orders", "my", Record<string, unknown> | undefined];
+    myDetail: (id: string) => readonly ["orders", "my", "detail", string];
+};
+declare const useOrders: (token: string | null, params?: Record<string, unknown>, options?: ListOptions) => ListQueryResult<Order>;
+declare const useOrderDetail: (id: string | null, token: string | null, options?: DetailOptions) => DetailQueryResult<Order>;
+declare const useOrderActions: () => CrudActions<CreateOrderPayload, Partial<Order>>;
+declare const useOrderNavigation: () => NavigateFn<Order>;
+interface QueryOptions$2 {
+    enabled?: boolean;
+    staleTime?: number;
+}
+interface UseMyOrdersReturn {
+    orders: Order[];
+    total: number;
+    page: number;
+    limit: number;
+    hasMore: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+interface UseCustomerOrderActionsReturn {
+    checkout: (data: CreateOrderPayload) => Promise<Order>;
+    isCheckingOut: boolean;
+    requestCancel: (params: {
+        orderId: string;
+        reason?: string;
+    }) => Promise<Order>;
+    isRequestingCancel: boolean;
+    isLoading: boolean;
+}
+interface UseAdminOrderActionsReturn {
+    updateStatus: (params: {
+        orderId: string;
+        status: string;
+        note?: string;
+    }) => Promise<Order>;
+    isUpdatingStatus: boolean;
+    fulfillOrder: (params: FulfillOrderPayload & {
+        orderId: string;
+    }) => Promise<Order>;
+    isFulfilling: boolean;
+    refundOrder: (params: {
+        orderId: string;
+        amount?: number;
+        reason?: string;
+    }) => Promise<Order>;
+    isRefunding: boolean;
+    cancelOrder: (params: {
+        orderId: string;
+        reason?: string;
+        refund?: boolean;
+    }) => Promise<Order>;
+    isCancelling: boolean;
+    requestShipping: (params: RequestShippingPayload & {
+        orderId: string;
+    }) => Promise<OrderShipping>;
+    isRequestingShipping: boolean;
+    updateShipping: (params: UpdateShippingPayload & {
+        orderId: string;
+    }) => Promise<OrderShipping>;
+    isUpdatingShipping: boolean;
+    isLoading: boolean;
+}
+/**
+ * Get customer's own orders
+ *
+ * @param token - Auth token
+ * @param params - Query params { page, limit, status, sort }
+ * @param options - Query options
+ *
+ * @example
+ * ```tsx
+ * function MyOrdersPage() {
+ *   const { orders, isLoading, hasMore } = useMyOrders(token, { limit: 10 });
+ *
+ *   return (
+ *     <OrderList orders={orders} loading={isLoading} />
+ *   );
+ * }
+ * ```
+ */
+declare function useMyOrders(token: string, params?: Record<string, unknown>, options?: QueryOptions$2): UseMyOrdersReturn;
+/**
+ * Get customer's own order detail
+ *
+ * @param token - Auth token
+ * @param orderId - Order ID
+ * @param options - Query options
+ *
+ * @example
+ * ```tsx
+ * function OrderDetailPage({ orderId }) {
+ *   const { data: order, isLoading } = useMyOrderDetail(token, orderId);
+ *
+ *   if (isLoading) return <Skeleton />;
+ *   return <OrderDetail order={order} />;
+ * }
+ * ```
+ */
+declare function useMyOrderDetail(token: string, orderId: string, options?: QueryOptions$2): _tanstack_react_query.UseQueryResult<Order, Error>;
+/**
+ * Customer order actions (checkout, request cancellation)
+ *
+ * @param token - Customer auth token
+ *
+ * @example
+ * ```tsx
+ * function CheckoutButton({ cart }) {
+ *   const { checkout, isCheckingOut } = useCustomerOrderActions(token);
+ *
+ *   const handleCheckout = async () => {
+ *     const order = await checkout({
+ *       items: cart.items,
+ *       shipping: shippingAddress,
+ *       payment: { method: 'bkash' },
+ *     });
+ *     router.push(`/orders/${order._id}`);
+ *   };
+ *
+ *   return (
+ *     <Button onClick={handleCheckout} disabled={isCheckingOut}>
+ *       {isCheckingOut ? 'Processing...' : 'Place Order'}
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCustomerOrderActions(token: string): UseCustomerOrderActionsReturn;
+/**
+ * Admin order actions (status, fulfill, refund, cancel, shipping)
+ *
+ * @param token - Admin auth token
+ *
+ * @example
+ * ```tsx
+ * function OrderActions({ order }) {
+ *   const {
+ *     updateStatus,
+ *     fulfillOrder,
+ *     cancelOrder,
+ *     isLoading,
+ *   } = useAdminOrderActions(token);
+ *
+ *   return (
+ *     <>
+ *       <Button onClick={() => updateStatus({ orderId: order._id, status: 'processing' })}>
+ *         Mark Processing
+ *       </Button>
+ *       <Button onClick={() => fulfillOrder({ orderId: order._id, branchId: 'branch_123' })}>
+ *         Fulfill Order
+ *       </Button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useAdminOrderActions(token: string): UseAdminOrderActionsReturn;
+
+interface QueryOptions$1 {
+    enabled?: boolean;
+    staleTime?: number;
+}
+type MembershipAction = "enroll" | "deactivate" | "reactivate" | "adjust";
+type PointsType = "bonus" | "correction" | "manual_redemption" | "redemption" | "expiry";
+interface MembershipActionParams {
+    id: string;
+    action: MembershipAction;
+    points?: number;
+    reason?: string;
+    type?: PointsType;
+}
+interface UseCustomerMembershipReturn {
+    membershipAction: (params: MembershipActionParams) => Promise<Customer>;
+    isPending: boolean;
+}
+/**
+ * Customer hooks using createCrudHooks factory
+ *
+ * Provides:
+ * - useCustomers: List customers with filtering/pagination
+ * - useCustomerDetail: Get single customer
+ * - useCustomerActions: Create, update, delete mutations
+ * - useCustomerNavigation: Navigation between customers
+ */
+declare const customerHooks: CrudHooksReturn<Customer, CustomerPayload, CustomerPayload>;
+declare const CUSTOMER_KEYS: QueryKeys;
+declare const useCustomers: (token: string | null, params?: Record<string, unknown>, options?: ListOptions) => ListQueryResult<Customer>;
+declare const useCustomerDetail: (id: string | null, token: string | null, options?: DetailOptions) => DetailQueryResult<Customer>;
+declare const useCustomerActions: () => CrudActions<CustomerPayload, CustomerPayload>;
+declare const useCustomerNavigation: () => NavigateFn<Customer>;
+/**
+ * Get current user's customer profile
+ *
+ * @param token - Auth token
+ * @param options - Query options
+ *
+ * @example
+ * ```tsx
+ * function ProfilePage() {
+ *   const { data: customer, isLoading } = useCurrentCustomer(token);
+ *
+ *   if (isLoading) return <Skeleton />;
+ *   return (
+ *     <div>
+ *       <h1>{customer?.name}</h1>
+ *       <p>Points: {customer?.membership?.points || 0}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useCurrentCustomer(token: string, options?: QueryOptions$1): _tanstack_react_query.UseQueryResult<Customer, Error>;
+/**
+ * Customer membership actions (enroll, deactivate, reactivate, adjust points)
+ *
+ * @param token - Admin auth token
+ *
+ * @example
+ * ```tsx
+ * function MembershipManager({ customer }) {
+ *   const { membershipAction, isPending } = useCustomerMembership(token);
+ *
+ *   const handleEnroll = async () => {
+ *     await membershipAction({
+ *       id: customer._id,
+ *       action: 'enroll',
+ *     });
+ *   };
+ *
+ *   const handleAdjustPoints = async (points: number) => {
+ *     await membershipAction({
+ *       id: customer._id,
+ *       action: 'adjust',
+ *       points,
+ *       type: 'bonus',
+ *       reason: 'Birthday bonus',
+ *     });
+ *   };
+ *
+ *   return (
+ *     <Button onClick={handleEnroll} disabled={isPending}>
+ *       Enroll in Membership
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCustomerMembership(token: string): UseCustomerMembershipReturn;
+
+declare const POS_KEYS: {
+    all: readonly ["pos"];
+    products: (branchId?: string) => readonly ["pos", "products", string | undefined];
+    productsList: (branchId?: string, params?: Record<string, unknown>) => readonly ["pos", "products", string | undefined, Record<string, unknown> | undefined];
+    lookup: (code: string, branchId?: string) => readonly ["pos", "lookup", string, string | undefined];
+    orders: () => readonly ["pos", "orders"];
+    receipt: (orderId: string) => readonly ["pos", "orders", string, "receipt"];
+};
+interface PosProductFilters {
+    category?: string;
+    search?: string;
+    inStockOnly?: boolean;
+    lowStockOnly?: boolean;
+    after?: string;
+    limit?: number;
+    sort?: string;
+    [key: string]: unknown;
+}
+interface UsePosProductsReturn {
+    products: PosProduct[];
+    summary: PosProductsResponse["summary"];
+    branch: PosProductsResponse["branch"];
+    hasMore: boolean;
+    nextCursor: string | null;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+interface QueryOptions {
+    enabled?: boolean;
+}
+/**
+ * Fetch POS products with branch-specific stock
+ *
+ * @param token - Auth token
+ * @param branchId - Branch to get stock for
+ * @param filters - Product filters
+ * @param options - Query options
+ *
+ * @example
+ * ```tsx
+ * function ProductGrid({ branchId }) {
+ *   const { products, isLoading, summary } = usePosProducts(token, branchId, {
+ *     category: 'electronics',
+ *     inStockOnly: true,
+ *   });
+ *
+ *   return (
+ *     <Grid>
+ *       {products.map(product => (
+ *         <ProductCard key={product._id} product={product} />
+ *       ))}
+ *     </Grid>
+ *   );
+ * }
+ * ```
+ */
+declare function usePosProducts(token: string, branchId: string | undefined, filters?: PosProductFilters, options?: QueryOptions): UsePosProductsReturn;
+/**
+ * Lookup product by barcode/SKU (query-based)
+ *
+ * @param token - Auth token
+ * @param code - Barcode or SKU to lookup
+ * @param branchId - Branch for stock info
+ * @param options - Query options
+ */
+declare function usePosLookup(token: string, code: string, branchId?: string, options?: QueryOptions): _tanstack_react_query.UseQueryResult<PosLookupResponse, Error>;
+/**
+ * Lookup product by barcode/SKU (mutation-based)
+ * Preferred for "scan -> act" flows
+ *
+ * @param token - Auth token
+ *
+ * @example
+ * ```tsx
+ * function BarcodeScanner() {
+ *   const { lookup, isLooking } = usePosLookupMutation(token);
+ *
+ *   const handleScan = async (code: string) => {
+ *     const result = await lookup({ code, branchId });
+ *     if (result) addToCart(result.data);
+ *   };
+ * }
+ * ```
+ */
+declare function usePosLookupMutation(token: string): {
+    lookup: _tanstack_react_query.UseMutateAsyncFunction<PosLookupResponse, Error, {
+        code: string;
+        branchId?: string;
+    }, unknown>;
+    isLooking: boolean;
+    error: Error | null;
+};
+/**
+ * Get receipt for an order
+ *
+ * @param token - Auth token
+ * @param orderId - Order ID
+ * @param options - Query options
+ */
+declare function usePosReceipt(token: string, orderId: string, options?: QueryOptions): _tanstack_react_query.UseQueryResult<PosReceiptResponse, Error>;
+interface UsePosOrdersReturn {
+    createOrder: (data: PosOrderPayload) => Promise<unknown>;
+    isCreatingOrder: boolean;
+}
+/**
+ * POS order operations
+ *
+ * @param token - Auth token
+ *
+ * @example
+ * ```tsx
+ * function Checkout({ cart, branchId }) {
+ *   const { createOrder, isCreatingOrder } = usePosOrders(token);
+ *
+ *   const handleCheckout = async () => {
+ *     const order = await createOrder({
+ *       items: cart.items,
+ *       branchId,
+ *       payment: { method: 'cash' },
+ *     });
+ *     // Handle success (show receipt, clear cart, etc.)
+ *   };
+ * }
+ * ```
+ */
+declare function usePosOrders(token: string): UsePosOrdersReturn;
+interface UsePosStockActionsReturn {
+    adjustStock: (data: CreateAdjustmentPayload) => Promise<unknown>;
+    isAdjusting: boolean;
+    setStock: (params: {
+        productId: string;
+        quantity: number;
+        branchId?: string;
+        variantSku?: string;
+        reason?: string;
+    }) => Promise<unknown>;
+    isSetting: boolean;
+    bulkAdjust: (data: BulkAdjustmentPayload) => Promise<unknown>;
+    isBulkAdjusting: boolean;
+    isLoading: boolean;
+}
+/**
+ * POS stock adjustment actions
+ *
+ * @param token - Auth token
+ * @param branchId - Branch for cache invalidation
+ *
+ * @example
+ * ```tsx
+ * function StockAdjuster({ product, branchId }) {
+ *   const { setStock, isSetting } = usePosStockActions(token, branchId);
+ *
+ *   const handleSetStock = async (newQuantity: number) => {
+ *     await setStock({
+ *       productId: product._id,
+ *       quantity: newQuantity,
+ *       reason: 'Inventory count',
+ *     });
+ *   };
+ * }
+ * ```
+ */
+declare function usePosStockActions(token: string, branchId?: string): UsePosStockActionsReturn;
+/**
+ * Generate idempotency key for POS orders
+ * Format: pos_{terminal}_{timestamp}_{counter}
+ */
+declare function generateIdempotencyKey(terminalId?: string): string;
+/**
+ * Calculate price for variant product
+ */
+declare function calculateVariantPrice(basePrice: number, priceModifier?: number): number;
+/**
+ * Format variant attributes for display
+ */
+declare function formatVariantLabel(attributes?: Record<string, string>): string;
+/**
+ * Check if product has variants
+ */
+declare function isVariantProduct(product: PosProduct): boolean;
+/**
+ * Get available (active) variants for a product
+ */
+declare function getAvailableVariants(product: PosProduct): ProductVariant[];
+/**
+ * Find variant by SKU
+ */
+declare function findVariantBySku(product: PosProduct, sku: string): ProductVariant | null;
+/**
+ * Get variant stock for branch
+ */
+declare function getVariantStock(product: PosProduct, variantSku: string): number;
+/**
+ * Check if product/variant is in stock
+ */
+declare function isInStock(product: PosProduct, variantSku?: string): boolean;
+/**
+ * Get product image URL (thumbnail preferred)
+ */
+declare function getPosProductImage(product: PosProduct): string;
+
+export { AddCartItemPayload, CART_KEYS, CUSTOMER_KEYS, Cart, CartItem, type CartOptions, CreateOrderPayload, Customer, CustomerPayload, FulfillOrderPayload, type MembershipActionParams, ORDER_KEYS, Order, OrderShipping, POS_KEYS, PosLookupResponse, PosOrderPayload, PosProduct, type PosProductFilters, PosProductsResponse, PosReceiptResponse, RequestShippingPayload, UpdateCartItemPayload, UpdateShippingPayload, type UseAdminOrderActionsReturn, type UseCartCountReturn, type UseCartReturn, type UseCustomerMembershipReturn, type UseCustomerOrderActionsReturn, type UseMyOrdersReturn, type UsePosOrdersReturn, type UsePosProductsReturn, type UsePosStockActionsReturn, calculateCartSubtotal, calculateItemPrice, calculateItemTotal, calculateVariantPrice, customerHooks, findVariantBySku, formatVariantAttributes, formatVariantLabel, generateIdempotencyKey, getAvailableVariants, getCartItemCount, getCartItemVariant, getPosProductImage, getVariantStock, isInStock, isVariantProduct, orderHooks, useAdminOrderActions, useCart, useCartCount, useCurrentCustomer, useCustomerActions, useCustomerDetail, useCustomerMembership, useCustomerNavigation, useCustomerOrderActions, useCustomers, useMyOrderDetail, useMyOrders, useOrderActions, useOrderDetail, useOrderNavigation, useOrders, usePosLookup, usePosLookupMutation, usePosOrders, usePosProducts, usePosReceipt, usePosStockActions };

package/dist/sales/index.js

@@ -0,0 +1,9 @@
+"use client";
+export { CART_KEYS, CUSTOMER_KEYS, CustomerApi, ORDER_KEYS, OrderStatus, POS_KEYS, PaymentStatus, calculateCartSubtotal, calculateItemPrice, calculateItemTotal, calculateVariantPrice, cartApi, customerApi, customerHooks, findVariantBySku, formatVariantAttributes, formatVariantLabel, generateIdempotencyKey, getAvailableVariants, getCartItemCount, getCartItemVariant, getPosProductImage, getVariantStock, isInStock, isVariantProduct, orderApi, order_default as orderApiDefault, orderHooks, useAdminOrderActions, useCart, useCartCount, useCurrentCustomer, useCustomerActions, useCustomerDetail, useCustomerMembership, useCustomerNavigation, useCustomerOrderActions, useCustomers, useMyOrderDetail, useMyOrders, useOrderActions, useOrderDetail, useOrderNavigation, useOrders, usePosLookup, usePosLookupMutation, usePosOrders, usePosProducts, usePosReceipt, usePosStockActions } from '../chunk-ANYGZ6O5.js';
+export { posApi, pos_default as posApiDefault } from '../chunk-CILP56G2.js';
+import '../chunk-QCTXAMLA.js';
+import '../chunk-B6MPVOV7.js';
+import '../chunk-U3XT35GZ.js';
+import '../chunk-IHCBBLLW.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/sales/index.js.map

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

package/dist/server.d.ts

@@ -0,0 +1,23 @@
+import { SDKConfig } from './core/index.js';
+export { configureSDK, getBaseUrl, getSDKConfig, handleApiRequest } from './core/index.js';
+export { a as CommerceSDKClient, C as CommerceSDKConfig, c as createCommerceSDK, i as initCommerceSDK } from './client-Cs7E_usr.js';
+export { a as authApi, 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';
+export { c as categoryApi, p as productApi, s as sizeGuideApi } from './size-guide-DgjzjM5P.js';
+export { p as cartApi, r as customerApi, q as orderApi, t as posApi } from './pos-BCqkx2-K.js';
+export { t as transactionApi } from './transaction-Bf6WjYCh.js';
+export { b as branchApi, c as couponApi, p as platformConfigApi, u as userApi } from './coupon-CDzL4bJG.js';
+export { g as getCmsPage, m as mediaApi, u as updateCmsPage } from './media-CNLJK93J.js';
+export { a as adjustmentApi, m as movementApi, p as purchaseApi, r as requestApi, s as stockApi, b as supplierApi, t as transferApi } from './stock-CfrU5_Wr.js';
+export { l as logisticsApi } from './logistics-CrpKadKE.js';
+export { f as financeApi } from './finance-BJdfKRw0.js';
+export { p as paymentApi } from './payment-BRboLqvU.js';
+export { a as analyticsApi } from './analytics-DMcD-o8w.js';
+import './api-factory-B_h4RKBm.js';
+import './product-p09zXkXB.js';
+import './order-B3dCvHgK.js';
+import './inventory-B5pssqRx.js';
+import './transaction-dL3WW-er.js';
+
+declare function runWithSDKConfig<T>(config: SDKConfig, fn: () => T): T;
+
+export { runWithSDKConfig };

package/dist/server.js

@@ -0,0 +1,37 @@
+export { createCommerceSDK, initCommerceSDK } from './chunk-J4JBQET2.js';
+export { logisticsApi } from './chunk-2YAZ5WG6.js';
+export { financeApi } from './chunk-N43VE355.js';
+export { transactionApi } from './chunk-AQAISI4F.js';
+export { getCmsPage, mediaApi, updateCmsPage } from './chunk-ERQ52WHY.js';
+export { branchApi, couponApi, platformConfigApi, userApi } from './chunk-YYFKLOKO.js';
+export { paymentApi } from './chunk-5E57JODA.js';
+export { analyticsApi } from './chunk-RIKAPJNG.js';
+export { authApi, createUser, forgetPassApi, getProfile, getUser, getUserByPhone, loginApi, registerApi, resetPassApi, tokenRefreshApi, updateUser, verifyManagerAuth } from './chunk-W22WB3WZ.js';
+export { categoryApi, productApi, sizeGuideApi } from './chunk-FOTUJPM4.js';
+import './chunk-PYYLHUV6.js';
+export { cartApi, customerApi, orderApi } from './chunk-ANYGZ6O5.js';
+import './chunk-LRV7MWWX.js';
+export { purchaseApi } from './chunk-L4OEI4VZ.js';
+export { transferApi } from './chunk-36NLLAVH.js';
+export { requestApi } from './chunk-2TF7QNYV.js';
+export { movementApi } from './chunk-24FDD6UR.js';
+export { adjustmentApi } from './chunk-3OYSJB3P.js';
+export { supplierApi } from './chunk-7LZCW4VF.js';
+export { stockApi } from './chunk-X2CQFJPR.js';
+export { posApi } from './chunk-CILP56G2.js';
+import './chunk-QCTXAMLA.js';
+import './chunk-B6MPVOV7.js';
+import './chunk-U3XT35GZ.js';
+import { setSDKConfigProvider } from './chunk-IHCBBLLW.js';
+export { configureSDK, getBaseUrl, getSDKConfig, handleApiRequest } from './chunk-IHCBBLLW.js';
+import { AsyncLocalStorage } from 'async_hooks';
+
+var configStore = new AsyncLocalStorage();
+setSDKConfigProvider(() => configStore.getStore() ?? null);
+function runWithSDKConfig(config, fn) {
+  return configStore.run(config, fn);
+}
+
+export { runWithSDKConfig };
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/server-context.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,IAAM,WAAA,GAAc,IAAI,iBAAA,EAA6B;AAErD,oBAAA,CAAqB,MAAM,WAAA,CAAY,QAAA,EAAS,IAAK,IAAI,CAAA;AAElD,SAAS,gBAAA,CAAoB,QAAmB,EAAA,EAAgB;AACrE,EAAA,OAAO,WAAA,CAAY,GAAA,CAAI,MAAA,EAAQ,EAAE,CAAA;AACnC","file":"server.js","sourcesContent":["import { AsyncLocalStorage } from \"node:async_hooks\";\n\nimport { setSDKConfigProvider, type SDKConfig } from \"./api-handler\";\n\nconst configStore = new AsyncLocalStorage<SDKConfig>();\n\nsetSDKConfigProvider(() => configStore.getStore() ?? null);\n\nexport function runWithSDKConfig<T>(config: SDKConfig, fn: () => T): T {\n  return configStore.run(config, fn);\n}\n"]}