omni-sync-sdk 0.1.1 → 0.3.0

package/dist/index.d.mts

@@ -1,8 +1,41 @@
 interface OmniSyncClientOptions {
     /**
-     * API Key for authentication (starts with "omni_")
+     * Connection ID for vibe-coded sites (starts with "vc_").
+     * This is the simplest way to connect - just use your Connection ID!
+     * Safe to use in frontend applications.
+     *
+     * @example
+     * ```typescript
+     * // Vibe-coded site usage - simplest option!
+     * const omni = new OmniSyncClient({
+     *   connectionId: 'vc_abc123xyz...',
+     * });
+     * const products = await omni.getProducts();
+     * ```
+     */
+    connectionId?: string;
+    /**
+     * Store ID for public storefront access (no API key needed).
+     * Use this for frontend/browser applications.
+     *
+     * @example
+     * ```typescript
+     * // Frontend usage - safe to expose
+     * const omni = new OmniSyncClient({ storeId: 'store_abc123' });
+     * ```
      */
-    apiKey: string;
+    storeId?: string;
+    /**
+     * API Key for admin/backend access (starts with "omni_").
+     * Keep this secret - never expose in frontend code!
+     *
+     * @example
+     * ```typescript
+     * // Backend usage - keep secret
+     * const omni = new OmniSyncClient({ apiKey: process.env.OMNI_API_KEY });
+     * ```
+     */
+    apiKey?: string;
     /**
      * Base URL of the Omni-Sync API
      * @default "https://api.omni-sync.com"
@@ -14,6 +47,24 @@ interface OmniSyncClientOptions {
      */
     timeout?: number;
 }
+interface StoreInfo {
+    id: string;
+    name: string;
+    currency: string;
+    language: string;
+}
+interface CustomerProfile {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    emailVerified: boolean;
+    acceptsMarketing: boolean;
+    addresses: CustomerAddress[];
+    createdAt: string;
+    updatedAt: string;
+}
 interface Product {
     id: string;
     name: string;
@@ -373,6 +424,14 @@ interface UpdateCustomerDto {
     tags?: string[];
     metadata?: Record<string, unknown>;
 }
+interface CustomerQueryParams {
+    page?: number;
+    limit?: number;
+    search?: string;
+    hasAccount?: boolean;
+    sortBy?: 'createdAt' | 'email' | 'firstName' | 'lastName' | 'lastOrderAt';
+    sortOrder?: 'asc' | 'desc';
+}
 interface CreateAddressDto {
     label?: string;
     firstName: string;
@@ -471,6 +530,9 @@ interface AddToCartDto {
 interface UpdateCartItemDto {
     quantity: number;
 }
+interface ApplyCouponDto {
+    code: string;
+}
 interface MergeCartsDto {
     sourceSessionToken: string;
     targetCustomerId: string;
@@ -564,6 +626,9 @@ interface SetShippingAddressDto {
 interface SetBillingAddressDto extends SetShippingAddressDto {
     sameAsShipping?: boolean;
 }
+interface SelectShippingMethodDto {
+    shippingRateId: string;
+}
 interface SetShippingAddressResponse {
     checkout: Checkout;
     rates: ShippingRate[];
@@ -580,6 +645,184 @@ interface WebhookEvent {
     timestamp: string;
 }
 type WebhookEventType = 'product.created' | 'product.updated' | 'product.deleted' | 'inventory.updated' | 'order.created' | 'order.updated' | 'coupon.created' | 'coupon.updated' | 'coupon.deleted' | 'cart.created' | 'cart.updated' | 'cart.abandoned' | 'checkout.started' | 'checkout.completed' | 'checkout.failed';
+type VariantStatus = 'active' | 'draft';
+interface CreateVariantDto {
+    sku?: string;
+    name?: string;
+    attributes?: Record<string, unknown>;
+    price?: number;
+    salePrice?: number;
+    inventory?: number;
+    image?: unknown;
+    position?: number;
+    status?: VariantStatus;
+}
+interface UpdateVariantDto {
+    sku?: string;
+    name?: string;
+    attributes?: Record<string, unknown>;
+    price?: number;
+    salePrice?: number;
+    image?: string | unknown;
+    position?: number;
+    status?: VariantStatus;
+}
+interface VariantPlatformOverlay {
+    price?: number;
+    salePrice?: number;
+    sku?: string;
+    stock?: number;
+    name?: string;
+}
+interface BulkVariantInput {
+    id?: string;
+    sku: string;
+    name?: string;
+    attributes: Record<string, string>;
+    price?: number | null;
+    salePrice?: number | null;
+    stock: number;
+    image?: unknown | null;
+    isEnabled: boolean;
+    isDeleted?: boolean;
+    overlays?: Record<string, VariantPlatformOverlay>;
+}
+interface ProductAttributeInput {
+    attributeId: string;
+    selectedOptionIds: string[];
+    isForVariations: boolean;
+}
+interface BulkSaveVariantsDto {
+    variants: BulkVariantInput[];
+    productAttributes?: ProductAttributeInput[];
+}
+interface BulkSaveVariantsResponse {
+    created: number;
+    updated: number;
+    deleted: number;
+    variants: ProductVariant[];
+}
+interface UpdateVariantInventoryDto {
+    newTotal: number;
+    reason?: string;
+}
+interface VariantInventoryResponse {
+    total: number;
+    reserved: number;
+    available: number;
+    lastInventorySyncAt?: string | null;
+}
+type RefundType = 'full' | 'partial';
+interface RefundLineItem {
+    lineItemId: string;
+    quantity: number;
+}
+interface CreateRefundDto {
+    type: RefundType;
+    items?: RefundLineItem[];
+    restockInventory?: boolean;
+    notifyCustomer?: boolean;
+    reason?: string;
+}
+interface RefundLineItemResponse {
+    name: string;
+    quantity: number;
+    amount: string;
+}
+interface Refund {
+    id: string;
+    createdAt: string;
+    amount: string;
+    currency: string;
+    reason?: string;
+    items?: RefundLineItemResponse[];
+    status: string;
+}
+interface UpdateOrderShippingDto {
+    firstName?: string;
+    lastName?: string;
+    name?: string;
+    company?: string;
+    line1: string;
+    line2?: string;
+    city: string;
+    state?: string;
+    country: string;
+    postalCode: string;
+    phone?: string;
+}
+interface FulfillOrderDto {
+    trackingNumber?: string;
+    trackingCompany?: string;
+    notifyCustomer?: boolean;
+}
+interface CompleteDraftDto {
+    paymentPending?: boolean;
+}
+interface SendInvoiceDto {
+    to?: string;
+    subject?: string;
+    customMessage?: string;
+}
+interface AppliedDiscount {
+    valueType: 'fixed_amount' | 'percentage';
+    value: string;
+    description?: string;
+    title?: string;
+}
+interface DraftLineItem {
+    variantId?: number;
+    quantity?: number;
+    title?: string;
+    price?: string;
+    appliedDiscount?: AppliedDiscount;
+}
+interface ShippingLine {
+    title: string;
+    price: string;
+}
+interface UpdateDraftDto {
+    note?: string;
+    tags?: string;
+    email?: string;
+    shippingAddress?: Record<string, unknown>;
+    billingAddress?: Record<string, unknown>;
+    lineItems?: DraftLineItem[];
+    appliedDiscount?: AppliedDiscount;
+    shippingLine?: ShippingLine;
+}
+interface EditInventoryDto {
+    productId: string;
+    newTotal: number;
+    reason?: string;
+}
+interface InventorySyncStatus {
+    total: number;
+    pending: number;
+    synced: number;
+    neverSynced: number;
+    lastSyncAt: string | null;
+}
+interface BulkInventoryResponse {
+    productId: string;
+    total: number;
+    reserved: number;
+    available: number;
+}
+interface ReconcileInventoryResponse {
+    productId?: string;
+    results?: unknown;
+    total?: number;
+    reconciled?: number;
+    discrepancies?: number;
+}
+interface PublishProductResponse {
+    productId: string;
+    results: Record<string, {
+        success: boolean;
+        error?: string;
+    }>;
+}
 interface OmniSyncApiError {
     statusCode: number;
     message: string;
@@ -588,37 +831,99 @@ interface OmniSyncApiError {
 }
 
 /**
- * OmniSyncClient - SDK for integrating vibe coding stores with Omni-Sync Platform
+ * OmniSyncClient - SDK for integrating stores with Omni-Sync Platform
  *
- * @example
+ * Three modes of operation:
+ *
+ * **Vibe-Coded Mode (Simplest)** - Use connectionId for vibe-coded sites:
  * ```typescript
- * const omni = new OmniSyncClient({
- *   apiKey: process.env.OMNI_SYNC_API_KEY!,
- * });
+ * const omni = new OmniSyncClient({ connectionId: 'vc_abc123...' });
+ * const products = await omni.getProducts();
+ * ```
  *
- * // Get products
+ * **Storefront Mode (Frontend)** - Use storeId for public access:
+ * ```typescript
+ * const omni = new OmniSyncClient({ storeId: 'store_abc123' });
  * const products = await omni.getProducts();
+ * ```
  *
- * // Create an order
- * const order = await omni.createOrder({
- *   items: [{ productId: 'prod_123', quantity: 2, price: 99.99 }],
- *   customer: { email: 'customer@example.com', name: 'John Doe' },
- *   totalAmount: 199.98,
- * });
+ * **Admin Mode (Backend)** - Use apiKey for full access:
+ * ```typescript
+ * const omni = new OmniSyncClient({ apiKey: process.env.OMNI_API_KEY });
+ * const orders = await omni.getOrders();
  * ```
  */
 declare class OmniSyncClient {
-    private readonly apiKey;
+    private readonly apiKey?;
+    private readonly storeId?;
+    private readonly connectionId?;
     private readonly baseUrl;
     private readonly timeout;
+    private customerToken;
     constructor(options: OmniSyncClientOptions);
+    /**
+     * Check if client is in vibe-coded mode (using connectionId)
+     */
+    isVibeCodedMode(): boolean;
+    /**
+     * Check if client is in storefront mode (using storeId)
+     */
+    isStorefrontMode(): boolean;
+    /**
+     * Check if client is in admin mode (using apiKey)
+     */
+    isAdminMode(): boolean;
+    /**
+     * Set the customer authentication token (obtained from login/register).
+     * Required for accessing customer-specific data in storefront mode.
+     *
+     * @example
+     * ```typescript
+     * const auth = await omni.loginCustomer('user@example.com', 'password');
+     * omni.setCustomerToken(auth.token);
+     *
+     * // Now can access customer data
+     * const profile = await omni.getMyProfile();
+     * ```
+     */
+    setCustomerToken(token: string | null): void;
+    /**
+     * Get the current customer token
+     */
+    getCustomerToken(): string | null;
+    /**
+     * Clear the customer token (logout)
+     */
+    clearCustomerToken(): void;
+    /**
+     * Make a request to the Admin API (requires apiKey)
+     */
+    private adminRequest;
+    /**
+     * Make a request to the Vibe-Coded API (public, uses connectionId)
+     */
+    private vibeCodedRequest;
+    /**
+     * Make a request to the Storefront API (public, uses storeId)
+     */
+    private storefrontRequest;
+    /**
+     * Smart request - uses storefront or admin API based on client mode
+     */
     private request;
+    /**
+     * Get store information
+     * Works in vibe-coded, storefront, and admin mode
+     */
+    getStoreInfo(): Promise<StoreInfo>;
     /**
      * Get a list of products with pagination
+     * Works in vibe-coded, storefront (public), and admin mode
      */
     getProducts(params?: ProductQueryParams): Promise<PaginatedResponse<Product>>;
     /**
      * Get a single product by ID
+     * Works in vibe-coded, storefront (public), and admin mode
      */
     getProduct(productId: string): Promise<Product>;
     /**
@@ -633,6 +938,111 @@ declare class OmniSyncClient {
      * Delete a product
      */
     deleteProduct(productId: string): Promise<void>;
+    /**
+     * Convert a SIMPLE product to VARIABLE product
+     *
+     * @example
+     * ```typescript
+     * const product = await omni.convertToVariable('prod_123');
+     * console.log('Product type:', product.type); // 'VARIABLE'
+     * ```
+     */
+    convertToVariable(productId: string): Promise<Product>;
+    /**
+     * Convert a VARIABLE product to SIMPLE product
+     * Note: This will delete all variants
+     *
+     * @example
+     * ```typescript
+     * const product = await omni.convertToSimple('prod_123');
+     * console.log('Product type:', product.type); // 'SIMPLE'
+     * ```
+     */
+    convertToSimple(productId: string): Promise<Product>;
+    /**
+     * Publish a product to specific platforms
+     *
+     * @example
+     * ```typescript
+     * const result = await omni.publishProduct('prod_123', ['SHOPIFY', 'WOOCOMMERCE']);
+     * console.log('Publish results:', result.results);
+     * ```
+     */
+    publishProduct(productId: string, platforms: string[]): Promise<PublishProductResponse>;
+    /**
+     * Create a new variant for a product
+     *
+     * @example
+     * ```typescript
+     * const variant = await omni.createVariant('prod_123', {
+     *   sku: 'PROD-SM-RED',
+     *   name: 'Small / Red',
+     *   attributes: { size: 'S', color: 'Red' },
+     *   price: 29.99,
+     *   inventory: 100,
+     * });
+     * ```
+     */
+    createVariant(productId: string, data: CreateVariantDto): Promise<ProductVariant>;
+    /**
+     * Bulk save variants (create, update, delete in one operation)
+     *
+     * @example
+     * ```typescript
+     * const result = await omni.bulkSaveVariants('prod_123', {
+     *   variants: [
+     *     { sku: 'SM-RED', attributes: { size: 'S', color: 'Red' }, stock: 10, isEnabled: true },
+     *     { id: 'var_456', sku: 'MD-BLUE', attributes: { size: 'M', color: 'Blue' }, stock: 5, isEnabled: true },
+     *     { id: 'var_789', sku: 'LG-GREEN', attributes: {}, stock: 0, isEnabled: false, isDeleted: true },
+     *   ],
+     * });
+     * console.log(`Created: ${result.created}, Updated: ${result.updated}, Deleted: ${result.deleted}`);
+     * ```
+     */
+    bulkSaveVariants(productId: string, data: BulkSaveVariantsDto): Promise<BulkSaveVariantsResponse>;
+    /**
+     * Update a variant
+     *
+     * @example
+     * ```typescript
+     * const variant = await omni.updateVariant('prod_123', 'var_456', {
+     *   price: 34.99,
+     *   salePrice: 29.99,
+     * });
+     * ```
+     */
+    updateVariant(productId: string, variantId: string, data: UpdateVariantDto): Promise<ProductVariant>;
+    /**
+     * Delete a variant
+     *
+     * @example
+     * ```typescript
+     * await omni.deleteVariant('prod_123', 'var_456');
+     * ```
+     */
+    deleteVariant(productId: string, variantId: string): Promise<void>;
+    /**
+     * Get inventory for a specific variant
+     *
+     * @example
+     * ```typescript
+     * const inventory = await omni.getVariantInventory('prod_123', 'var_456');
+     * console.log('Available:', inventory.available);
+     * ```
+     */
+    getVariantInventory(productId: string, variantId: string): Promise<VariantInventoryResponse>;
+    /**
+     * Update inventory for a specific variant
+     *
+     * @example
+     * ```typescript
+     * const inventory = await omni.updateVariantInventory('prod_123', 'var_456', {
+     *   newTotal: 50,
+     *   reason: 'Restocked from supplier',
+     * });
+     * ```
+     */
+    updateVariantInventory(productId: string, variantId: string, data: UpdateVariantInventoryDto): Promise<VariantInventoryResponse>;
     /**
      * Get a list of orders with pagination
      */
@@ -650,6 +1060,181 @@ declare class OmniSyncClient {
      * Update an order (e.g., change status)
      */
     updateOrder(orderId: string, data: UpdateOrderDto): Promise<Order>;
+    /**
+     * Update order status
+     *
+     * @example
+     * ```typescript
+     * const order = await omni.updateOrderStatus('order_123', 'shipped');
+     * ```
+     */
+    updateOrderStatus(orderId: string, status: string): Promise<Order>;
+    /**
+     * Update order payment method
+     * Note: Only WooCommerce supports syncing payment method changes back to platform
+     *
+     * @example
+     * ```typescript
+     * const order = await omni.updatePaymentMethod('order_123', 'credit_card');
+     * ```
+     */
+    updatePaymentMethod(orderId: string, paymentMethod: string): Promise<Order>;
+    /**
+     * Update order notes
+     *
+     * @example
+     * ```typescript
+     * const order = await omni.updateOrderNotes('order_123', 'Customer requested gift wrapping');
+     * ```
+     */
+    updateOrderNotes(orderId: string, notes: string): Promise<Order>;
+    /**
+     * Get refunds for an order
+     * Returns refunds from the source platform (Shopify/WooCommerce only)
+     *
+     * @example
+     * ```typescript
+     * const refunds = await omni.getOrderRefunds('order_123');
+     * console.log('Total refunds:', refunds.length);
+     * ```
+     */
+    getOrderRefunds(orderId: string): Promise<Refund[]>;
+    /**
+     * Create a refund for an order
+     * Creates refund on the source platform (Shopify/WooCommerce only)
+     *
+     * @example
+     * ```typescript
+     * // Full refund
+     * const refund = await omni.createRefund('order_123', {
+     *   type: 'full',
+     *   restockInventory: true,
+     *   notifyCustomer: true,
+     *   reason: 'Customer request',
+     * });
+     *
+     * // Partial refund
+     * const partialRefund = await omni.createRefund('order_123', {
+     *   type: 'partial',
+     *   items: [
+     *     { lineItemId: 'item_456', quantity: 1 },
+     *   ],
+     *   restockInventory: true,
+     * });
+     * ```
+     */
+    createRefund(orderId: string, data: CreateRefundDto): Promise<Refund>;
+    /**
+     * Update order shipping address
+     * Syncs to source platform (Shopify/WooCommerce only)
+     *
+     * @example
+     * ```typescript
+     * const order = await omni.updateOrderShipping('order_123', {
+     *   firstName: 'John',
+     *   lastName: 'Doe',
+     *   line1: '456 New Address',
+     *   city: 'Los Angeles',
+     *   state: 'CA',
+     *   country: 'US',
+     *   postalCode: '90001',
+     * });
+     * ```
+     */
+    updateOrderShipping(orderId: string, data: UpdateOrderShippingDto): Promise<Order>;
+    /**
+     * Cancel an order
+     * Works for Shopify and WooCommerce orders that haven't been fulfilled
+     *
+     * @example
+     * ```typescript
+     * const order = await omni.cancelOrder('order_123');
+     * console.log('Order status:', order.status); // 'cancelled'
+     * ```
+     */
+    cancelOrder(orderId: string): Promise<Order>;
+    /**
+     * Fulfill an order (mark as shipped)
+     * Works for Shopify and WooCommerce orders
+     *
+     * @example
+     * ```typescript
+     * const order = await omni.fulfillOrder('order_123', {
+     *   trackingNumber: '1Z999AA10123456784',
+     *   trackingCompany: 'UPS',
+     *   notifyCustomer: true,
+     * });
+     * ```
+     */
+    fulfillOrder(orderId: string, data?: FulfillOrderDto): Promise<Order>;
+    /**
+     * Sync draft orders from connected platforms
+     *
+     * @example
+     * ```typescript
+     * const result = await omni.syncDraftOrders();
+     * console.log('Draft orders synced');
+     * ```
+     */
+    syncDraftOrders(): Promise<{
+        message: string;
+    }>;
+    /**
+     * Complete a draft order (convert to regular order)
+     *
+     * @example
+     * ```typescript
+     * const order = await omni.completeDraftOrder('draft_123', {
+     *   paymentPending: false,
+     * });
+     * ```
+     */
+    completeDraftOrder(orderId: string, data?: CompleteDraftDto): Promise<Order>;
+    /**
+     * Send invoice for a draft order
+     *
+     * @example
+     * ```typescript
+     * await omni.sendDraftInvoice('draft_123', {
+     *   to: 'customer@example.com',
+     *   subject: 'Your Invoice',
+     *   customMessage: 'Thank you for your order!',
+     * });
+     * ```
+     */
+    sendDraftInvoice(orderId: string, data?: SendInvoiceDto): Promise<{
+        message: string;
+    }>;
+    /**
+     * Delete a draft order
+     *
+     * @example
+     * ```typescript
+     * await omni.deleteDraftOrder('draft_123');
+     * ```
+     */
+    deleteDraftOrder(orderId: string): Promise<void>;
+    /**
+     * Update a draft order
+     *
+     * @example
+     * ```typescript
+     * const order = await omni.updateDraftOrder('draft_123', {
+     *   note: 'Updated customer note',
+     *   email: 'newemail@example.com',
+     *   shippingAddress: {
+     *     firstName: 'John',
+     *     lastName: 'Doe',
+     *     address1: '123 Main St',
+     *     city: 'New York',
+     *     province: 'NY',
+     *     country: 'US',
+     *     zip: '10001',
+     *   },
+     * });
+     * ```
+     */
+    updateDraftOrder(orderId: string, data: UpdateDraftDto): Promise<Order>;
     /**
      * Update inventory for a product
      * This will sync inventory to all connected platforms
@@ -663,6 +1248,64 @@ declare class OmniSyncClient {
         reserved: number;
         total: number;
     }>;
+    /**
+     * Edit inventory manually with reason for audit trail
+     *
+     * @example
+     * ```typescript
+     * const inventory = await omni.editInventory({
+     *   productId: 'prod_123',
+     *   newTotal: 100,
+     *   reason: 'Restocked from warehouse',
+     * });
+     * ```
+     */
+    editInventory(data: EditInventoryDto): Promise<{
+        total: number;
+        reserved: number;
+        available: number;
+    }>;
+    /**
+     * Get inventory sync status for all products in the store
+     *
+     * @example
+     * ```typescript
+     * const status = await omni.getInventorySyncStatus();
+     * console.log(`${status.pending} products pending sync`);
+     * console.log(`Last sync: ${status.lastSyncAt}`);
+     * ```
+     */
+    getInventorySyncStatus(): Promise<InventorySyncStatus>;
+    /**
+     * Get inventory for multiple products at once
+     *
+     * @example
+     * ```typescript
+     * const inventories = await omni.getBulkInventory(['prod_123', 'prod_456', 'prod_789']);
+     * inventories.forEach(inv => {
+     *   console.log(`${inv.productId}: ${inv.available} available`);
+     * });
+     * ```
+     */
+    getBulkInventory(productIds: string[]): Promise<BulkInventoryResponse[]>;
+    /**
+     * Reconcile inventory between OmniSync and connected platforms
+     * Detects and optionally fixes discrepancies
+     *
+     * @example
+     * ```typescript
+     * // Reconcile single product (dry run)
+     * const result = await omni.reconcileInventory({ productId: 'prod_123' });
+     *
+     * // Reconcile all products with auto-fix
+     * const summary = await omni.reconcileInventory({ autoFix: true });
+     * console.log(`Reconciled ${summary.reconciled} products`);
+     * ```
+     */
+    reconcileInventory(options?: {
+        productId?: string;
+        autoFix?: boolean;
+    }): Promise<ReconcileInventoryResponse>;
     /**
      * Trigger a sync to a specific platform or all platforms
      */
@@ -671,16 +1314,6 @@ declare class OmniSyncClient {
      * Get the status of a sync job
      */
     getSyncStatus(jobId: string): Promise<SyncJob>;
-    /**
-     * Get information about the connected store
-     */
-    getStoreInfo(): Promise<{
-        id: string;
-        name: string;
-        currency: string;
-        language: string;
-        connectedPlatforms: ConnectorPlatform[];
-    }>;
     /**
      * Get a list of coupons with pagination
      */
@@ -1067,6 +1700,62 @@ declare class OmniSyncClient {
      * ```
      */
     completeCheckout(checkoutId: string): Promise<CompleteCheckoutResponse>;
+    /**
+     * Get the current customer's profile (requires customerToken)
+     * Only available in storefront mode
+     *
+     * @example
+     * ```typescript
+     * const auth = await omni.loginCustomer('user@example.com', 'password');
+     * omni.setCustomerToken(auth.token);
+     * const profile = await omni.getMyProfile();
+     * ```
+     */
+    getMyProfile(): Promise<CustomerProfile>;
+    /**
+     * Update the current customer's profile (requires customerToken)
+     * Only available in storefront mode
+     */
+    updateMyProfile(data: {
+        firstName?: string;
+        lastName?: string;
+        phone?: string;
+        acceptsMarketing?: boolean;
+    }): Promise<CustomerProfile>;
+    /**
+     * Get the current customer's orders (requires customerToken)
+     * Only available in storefront mode
+     */
+    getMyOrders(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResponse<Order>>;
+    /**
+     * Get the current customer's addresses (requires customerToken)
+     * Only available in storefront mode
+     */
+    getMyAddresses(): Promise<CustomerAddress[]>;
+    /**
+     * Add an address to the current customer (requires customerToken)
+     * Only available in storefront mode
+     */
+    addMyAddress(address: CreateAddressDto): Promise<CustomerAddress>;
+    /**
+     * Update a customer address (requires customerToken)
+     * Only available in storefront mode
+     */
+    updateMyAddress(addressId: string, data: UpdateAddressDto): Promise<CustomerAddress>;
+    /**
+     * Delete a customer address (requires customerToken)
+     * Only available in storefront mode
+     */
+    deleteMyAddress(addressId: string): Promise<void>;
+    /**
+     * Get the current customer's cart (requires customerToken)
+     * Creates a new cart if none exists
+     * Only available in storefront mode
+     */
+    getMyCart(): Promise<Cart>;
 }
 /**
  * Custom error class for Omni-Sync API errors
@@ -1087,7 +1776,7 @@ declare class OmniSyncError extends Error {
  *
  * @example
  * ```typescript
- * import { verifyWebhook } from '@omni-sync/sdk';
+ * import { verifyWebhook } from 'omni-sync-sdk';
  *
  * app.post('/webhooks/omni-sync', async (req, res) => {
  *   const signature = req.headers['x-omni-signature'];
@@ -1134,4 +1823,4 @@ declare function isWebhookEventType(event: WebhookEvent, type: WebhookEventType)
  */
 declare function createWebhookHandler(handlers: Partial<Record<WebhookEventType, (event: WebhookEvent) => Promise<void>>>): (payload: unknown) => Promise<void>;
 
-export { type ConnectorPlatform, type Coupon, type CouponCreateResponse, type CouponQueryParams, type CouponStatus, type CouponType, type CouponValidationWarning, type CreateCouponDto, type CreateOrderDto, type CreateProductDto, type InventoryInfo, type OmniSyncApiError, OmniSyncClient, type OmniSyncClientOptions, OmniSyncError, type Order, type OrderAddress, type OrderCustomer, type OrderItem, type OrderQueryParams, type OrderStatus, type PaginatedResponse, type PlatformCouponCapabilities, type Product, type ProductImage, type ProductQueryParams, type ProductVariant, type SyncJob, type UpdateCouponDto, type UpdateInventoryDto, type UpdateOrderDto, type UpdateProductDto, type WebhookEvent, type WebhookEventType, createWebhookHandler, isCouponApplicableToProduct, isWebhookEventType, parseWebhookEvent, verifyWebhook };
+export { type AddToCartDto, type AppliedDiscount, type ApplyCouponDto, type BulkInventoryResponse, type BulkSaveVariantsDto, type BulkSaveVariantsResponse, type BulkVariantInput, type Cart, type CartItem, type CartStatus, type Checkout, type CheckoutAddress, type CheckoutLineItem, type CheckoutStatus, type CompleteCheckoutResponse, type CompleteDraftDto, type ConnectorPlatform, type Coupon, type CouponCreateResponse, type CouponQueryParams, type CouponStatus, type CouponType, type CouponValidationWarning, type CreateAddressDto, type CreateCheckoutDto, type CreateCouponDto, type CreateCustomerDto, type CreateOrderDto, type CreateProductDto, type CreateRefundDto, type CreateVariantDto, type Customer, type CustomerAddress, type CustomerAuthResponse, type CustomerProfile, type CustomerQueryParams, type DraftLineItem, type EditInventoryDto, type FulfillOrderDto, type InventoryInfo, type InventorySyncStatus, type MergeCartsDto, type OmniSyncApiError, OmniSyncClient, type OmniSyncClientOptions, OmniSyncError, type Order, type OrderAddress, type OrderCustomer, type OrderItem, type OrderQueryParams, type OrderStatus, type PaginatedResponse, type PlatformCouponCapabilities, type Product, type ProductAttributeInput, type ProductImage, type ProductQueryParams, type ProductVariant, type PublishProductResponse, type ReconcileInventoryResponse, type Refund, type RefundLineItem, type RefundLineItemResponse, type RefundType, type RegisterCustomerDto, type SelectShippingMethodDto, type SendInvoiceDto, type SetBillingAddressDto, type SetCheckoutCustomerDto, type SetShippingAddressDto, type SetShippingAddressResponse, type ShippingLine, type ShippingRate, type StoreInfo, type SyncJob, type UpdateAddressDto, type UpdateCartItemDto, type UpdateCouponDto, type UpdateCustomerDto, type UpdateDraftDto, type UpdateInventoryDto, type UpdateOrderDto, type UpdateOrderShippingDto, type UpdateProductDto, type UpdateVariantDto, type UpdateVariantInventoryDto, type VariantInventoryResponse, type VariantPlatformOverlay, type VariantStatus, type WebhookEvent, type WebhookEventType, createWebhookHandler, isCouponApplicableToProduct, isWebhookEventType, parseWebhookEvent, verifyWebhook };