@sazito/client-sdk 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,1812 @@
+/**
+ * SDK Configuration
+ */
+interface CacheConfig {
+    enabled: boolean;
+    ttl?: number;
+}
+interface RetryConfig {
+    enabled: boolean;
+    retries: number;
+    retryDelay: number;
+}
+interface SazitoConfig {
+    domain: string;
+    timeout?: number;
+    retry?: RetryConfig;
+    cache?: {
+        products?: CacheConfig;
+        categories?: CacheConfig;
+        cart?: CacheConfig;
+        orders?: CacheConfig;
+        search?: CacheConfig;
+        cms?: CacheConfig;
+        tags?: CacheConfig;
+        entityRoutes?: CacheConfig;
+    };
+    customFetchApi?: typeof fetch;
+    debug?: boolean;
+}
+
+/**
+ * Common types used throughout the SDK
+ */
+/**
+ * Unified response pattern for all API calls
+ * No exceptions are thrown - errors are returned in the error field
+ */
+interface SazitoResponse<T> {
+    data?: T;
+    error?: {
+        status?: number;
+        message: string;
+        type: 'network' | 'api' | 'validation';
+        details?: any;
+    };
+}
+/**
+ * Paginated response wrapper
+ */
+interface PaginatedResponse<T> {
+    items: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+/**
+ * Request options that can be passed to any API call
+ */
+interface RequestOptions {
+    retries?: number;
+    timeout?: number;
+    cache?: boolean;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+/**
+ * Cookie options for token storage
+ */
+interface CookieOptions {
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    maxAge?: number;
+    path?: string;
+    domain?: string;
+}
+/**
+ * Image type used in products, categories, etc.
+ */
+interface Image {
+    id: number;
+    name: string;
+    url: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+    order?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Product attribute (e.g., color, size)
+ */
+interface ProductAttribute {
+    name: string;
+    value: string;
+}
+/**
+ * Region (استان)
+ */
+interface Region$1 {
+    id: number;
+    name: string;
+}
+/**
+ * City (شهر)
+ */
+interface City$1 {
+    id: number;
+    name: string;
+    regionId?: number;
+}
+
+/**
+ * Product-related types
+ */
+
+interface ProductVariant {
+    id: number;
+    productId?: number;
+    sku?: string;
+    enabled: boolean;
+    price: number;
+    originalPrice?: number;
+    stockQuantity: number;
+    isStockManaged: boolean;
+    isAvailable?: boolean;
+    attributes: ProductAttribute[];
+    hasMaxOrder: boolean;
+    maxOrderQuantity: number;
+    minOrderQuantity: number;
+    weight?: number;
+    dynamicFormId?: number;
+    sortIndex: number;
+    imageId?: number;
+    commercialFiles?: any[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface Product {
+    id?: number;
+    name: string;
+    url: string;
+    enabled: boolean;
+    productType: string;
+    themeConfig?: any;
+    dynamicFormId?: number;
+    eventEntityId?: number;
+    attributes?: ProductAttribute[];
+    images: Image[];
+    variants: ProductVariant[];
+    categories: ProductCategory[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface ProductCategory {
+    id?: number;
+    name: string;
+    url: string;
+    enabled?: boolean;
+    description?: string;
+    productsCount?: number;
+    themeConfig?: any;
+    attributes?: ProductAttribute[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Tag {
+    id: number;
+    name: string;
+    slug: string;
+}
+type ProductSort = 'newest' | 'best-selling' | 'availability' | 'discount' | '!price' | 'price';
+interface ProductFilters {
+    page?: number;
+    pageSize?: number;
+    sort?: ProductSort;
+    categories?: number | number[];
+    priceMin?: number;
+    priceMax?: number;
+    availableOnly?: boolean;
+    discountedOnly?: boolean;
+    pinnedIds?: number[];
+    similarTo?: number;
+}
+
+/**
+ * Cart-related types
+ */
+
+interface CartProduct {
+    id: number;
+    product: {
+        variantId: number;
+        name: string;
+        url: string;
+        image: Image;
+        attributes: ProductAttribute[];
+        hasMaxOrder: boolean;
+        maxOrderQuantity: number;
+        minOrderQuantity: number;
+    };
+    unitPrice: number;
+    lineTotal: number;
+    quantity: number;
+    formAttributes?: Record<string, any>;
+    bookingAttributes?: {
+        eventEntityId?: number;
+        timezone?: string;
+    };
+    formFields?: Record<string, any>;
+}
+interface Cart {
+    id: number;
+    identifier: string;
+    items: CartProduct[];
+    subtotal: number;
+    total: number;
+    needsShipping: boolean;
+    deleteCoupon: boolean;
+}
+interface CartCredentials {
+    id: number;
+    identifier: string;
+}
+interface AddToCartInput {
+    id: number;
+    count: number;
+    formAttributes?: Record<string, any>;
+    schedulerBookingAttributes?: {
+        eventEntityId: number;
+        timezone: string;
+    };
+}
+interface CreateCartInput {
+    coupon?: string;
+    variants: AddToCartInput[];
+    formAttributes?: Record<string, any>;
+    schedulerBookingAttributes?: {
+        eventEntityId: number;
+        timezone: string;
+    };
+}
+
+/**
+ * Invoice and checkout-related types
+ */
+
+interface InvoiceItem {
+    id: number;
+    variant: {
+        id: number;
+        product: any;
+        attributes: ProductAttribute[];
+    };
+    image: Image;
+    name: string;
+    unitPrice: number;
+    lineTotal: number;
+    quantity: number;
+    formAttributes?: Record<string, any>;
+    bookingAttributes?: Record<string, any>;
+    formFields?: Record<string, any>;
+}
+interface ShippingItem {
+    invoiceItemIds: number[];
+    rate: {
+        id: number;
+        shippingMethodId: number;
+        cost: number;
+        deliveryTime: string;
+        minDays: number;
+        maxDays: number;
+    };
+}
+interface ShippingAddress {
+    id: number;
+    identifier: string;
+    firstName: string;
+    lastName: string;
+    mobilePhone: string;
+    phoneNumber?: string;
+    email?: string;
+    region: Region$1;
+    city: City$1;
+    address: string;
+    postalCode?: string;
+    latitude?: number;
+    longitude?: number;
+    userSetCoordinatesBefore?: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface User {
+    id: number;
+    email?: string;
+    mobilePhone?: string;
+    firstName?: string;
+    lastName?: string;
+    birthDate?: string;
+}
+interface Invoice {
+    id: number;
+    identifier: string;
+    items: InvoiceItem[];
+    shippingAddress?: ShippingAddress;
+    shippingItems: ShippingItem[];
+    shippingMethod?: string;
+    needsShipping: boolean;
+    user?: User;
+    comment?: string;
+    subtotal: number;
+    total: number;
+    finalTotal: number;
+    discountTotal: number;
+    shippingTotal: number;
+    taxTotal: number;
+    discountCode?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface InvoiceCredentials {
+    id: number;
+    identifier: string;
+}
+interface CreateInvoiceInput {
+    cartId: number;
+    cartIdentifier: string;
+}
+interface RefreshInvoiceInput {
+    cartId: number;
+    cartIdentifier: string;
+    identifier: string;
+}
+
+/**
+ * Shipping-related types
+ */
+interface ShippingMethod {
+    id: number;
+    code: string;
+    name: string;
+    description: string;
+    enabled: boolean;
+    isFree: boolean;
+    isCourier: boolean;
+    isPost: boolean;
+}
+interface ShippingRate {
+    id: number;
+    shippingMethodId: number;
+    cost: number;
+    deliveryTime: string;
+    minDays: number;
+    maxDays: number;
+}
+interface ShippingAddressInput {
+    firstName: string;
+    lastName: string;
+    mobilePhone: string;
+    phoneNumber?: string;
+    email?: string;
+    regionId: number;
+    cityId: number;
+    address: string;
+    postalCode?: string;
+    latitude?: number;
+    longitude?: number;
+    userSetCoordinatesBefore?: boolean;
+}
+interface ShippingAddressCredentials {
+    id: number;
+    identifier: string;
+}
+interface ShippingAssignment {
+    rateId: number;
+    invoiceItemIds: string[];
+}
+
+/**
+ * Payment-related types
+ */
+type PaymentGateway = 'mellatpayment' | 'pecpayment' | 'sadadpayment' | 'zarinpalpayment' | 'paypingpayment' | 'podpayment' | 'uppayment' | 'seppayment' | 'vandarpayment' | 'yourgatepayment' | 'bazarpayment' | 'zifypayment' | 'zibalpayment' | 'snapppayment' | 'torobpaypayment' | 'azkipayment' | 'digipaypayment' | 'novapaypayment' | 'zarinpluspayment' | 'tomanpayment' | 'tarapayment' | 'ozonpayment' | 'millipaypayment' | 'ayriapayment' | 'sabinpayment' | 'paymentinplace' | 'cardtocardpayment' | 'freepayment';
+type PaymentStatus = 'PENDING' | 'PROCESSING' | 'PAID' | 'FAILED' | 'CANCELLED' | 'REFUNDED';
+interface PaymentMethod {
+    id: number;
+    code: PaymentGateway;
+    name: string;
+    description: {
+        description: string;
+        cardNumber?: string;
+        cardDescription?: string;
+        uploadNeeded?: boolean;
+    };
+    enabled: boolean;
+    config?: Record<string, any>;
+}
+interface Payment {
+    id: number;
+    identifier: string;
+    paymentType: PaymentMethod;
+    amount: number;
+    invoiceId: number;
+    status: PaymentStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+interface PaymentAction {
+    action: 'POST' | 'REDIRECT' | 'UPLOAD' | 'FAIL' | 'StockViolated';
+    address?: string;
+    payload?: Record<string, any>;
+    time?: number;
+    message?: string;
+}
+interface PaymentCredentials {
+    id: number;
+    identifier: string;
+}
+interface CreatePaymentInput {
+    invoiceId: number;
+    invoiceIdentifier: string;
+    paymentType: number;
+}
+interface PaymentStepInput {
+    identifier: string;
+    isFailed?: string;
+    imageUrl?: string;
+    code?: string;
+}
+
+/**
+ * Order-related types
+ */
+
+type OrderStatus = 'PENDING' | 'PROCESSING' | 'SHIPPED' | 'DELIVERED' | 'CANCELLED' | 'REFUNDED';
+interface Order {
+    id: number;
+    orderNumber: string;
+    status: OrderStatus;
+    items: InvoiceItem[];
+    shippingAddress?: ShippingAddress;
+    paymentMethod?: PaymentMethod;
+    subtotal: number;
+    discountTotal: number;
+    shippingTotal: number;
+    taxTotal: number;
+    total: number;
+    trackingNumber?: string;
+    notes?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface OrderFilters {
+    status?: OrderStatus;
+    page?: number;
+    pageSize?: number;
+}
+
+/**
+ * Search-related types
+ */
+
+/**
+ * CMS Page types
+ */
+type CMSPageType = 'normal' | 'blog';
+/**
+ * Blog page entity from search results
+ */
+interface BlogPage {
+    id?: number;
+    name: string;
+    url: string;
+    enabled?: boolean;
+    cmsPageType?: CMSPageType;
+    content?: string;
+    summary?: string;
+    image?: Image;
+    themeConfig?: any;
+    attributes?: ProductAttribute[];
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * CMS page entity from search results
+ */
+interface CmsPage {
+    id?: number;
+    name: string;
+    url: string;
+    enabled?: boolean;
+    cmsPageType?: CMSPageType;
+    content?: string;
+    summary?: string;
+    image?: Image;
+    themeConfig?: any;
+    attributes?: ProductAttribute[];
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Search response containing multiple entity types
+ * Each entity type has its own array and pagination info
+ */
+interface SearchResponse {
+    products: {
+        items: Product[];
+        total: number;
+        page: number;
+        pageSize: number;
+    };
+    blogPages: {
+        items: BlogPage[];
+        total: number;
+        page: number;
+        pageSize: number;
+    };
+    cmsPages: {
+        items: CmsPage[];
+        total: number;
+        page: number;
+        pageSize: number;
+    };
+    productCategories: {
+        items: ProductCategory[];
+        total: number;
+        page: number;
+        pageSize: number;
+    };
+}
+
+/**
+ * Entity Route types
+ * For resolving URL paths to entities (products, categories, CMS pages)
+ */
+
+/**
+ * Entity type discriminator
+ */
+type EntityType = 'product' | 'product_category' | 'cms_page' | 'blog_page' | 'unknown';
+/**
+ * Entity route response - polymorphic based on entity type
+ */
+interface EntityRoute {
+    entityType: EntityType;
+    entityId: number;
+    url: string;
+}
+/**
+ * Product entity route
+ */
+interface ProductEntityRoute extends EntityRoute {
+    entityType: 'product';
+    entity: Product;
+}
+/**
+ * Product category entity route
+ */
+interface ProductCategoryEntityRoute extends EntityRoute {
+    entityType: 'product_category';
+    entity: ProductCategory;
+}
+/**
+ * CMS page entity route
+ */
+interface CMSPageEntityRoute extends EntityRoute {
+    entityType: 'cms_page';
+    entity: CmsPage;
+}
+/**
+ * Blog page entity route
+ */
+interface BlogPageEntityRoute extends EntityRoute {
+    entityType: 'blog_page';
+    entity: BlogPage;
+}
+/**
+ * Unknown entity route (404)
+ */
+interface UnknownEntityRoute extends EntityRoute {
+    entityType: 'unknown';
+    entity?: never;
+}
+/**
+ * Union type for all possible entity routes
+ */
+type EntityRouteResponse = ProductEntityRoute | ProductCategoryEntityRoute | CMSPageEntityRoute | BlogPageEntityRoute | UnknownEntityRoute;
+
+/**
+ * Menu and Navigation Types
+ */
+/**
+ * Clean navigation menu item returned by SDK
+ */
+interface MenuItem {
+    name: string;
+    url: string;
+    children: MenuItem[];
+}
+/**
+ * Raw menu tree structure from API (camelCased by HTTP client)
+ */
+interface MenuTree {
+    id: number;
+    identifier: string;
+    treeStructure: {
+        nodes: MenuNode[];
+    };
+}
+/**
+ * Raw menu node from API (camelCased by HTTP client)
+ */
+interface MenuNode {
+    entityType: 'product_category' | 'product' | 'cms_page' | 'blog_page' | 'url';
+    entityId: number | null;
+    entity?: {
+        id?: number;
+        name?: string;
+        title?: string;
+        url?: string;
+        enabled?: boolean;
+    };
+    details?: {
+        title?: string;
+        isTitleDefault?: boolean;
+        url?: string;
+        name?: string;
+        entityType?: string;
+        includeChildren?: boolean;
+    };
+    children: MenuNode[];
+}
+
+/**
+ * Token storage for auth token persistence
+ * Primary storage: localStorage (user_id_token), with cookie fallback.
+ */
+
+declare class TokenStorage {
+    private readonly tokenKey;
+    /**
+     * Get token from localStorage (fallback to cookie)
+     */
+    get(): string | null;
+    /**
+     * Set token in localStorage and cookie fallback
+     */
+    set(token: string, options?: CookieOptions): void;
+    /**
+     * Remove token from both localStorage and cookie
+     */
+    remove(): void;
+    private getFromLocalStorage;
+    private setInLocalStorage;
+    private removeFromLocalStorage;
+    /**
+     * Parse document.cookie into key-value pairs
+     */
+    private parseCookies;
+    /**
+     * Set a cookie with options
+     */
+    private setCookie;
+}
+
+/**
+ * HTTP Client with native fetch
+ * Provides unified response pattern, retry logic, caching, and automatic data transformation
+ */
+
+declare class HttpClient {
+    private baseUrl;
+    private domain;
+    private config;
+    private tokenStorage;
+    private cache;
+    private fetchApi;
+    constructor(config: Required<SazitoConfig>);
+    /**
+     * GET request
+     */
+    get<T>(endpoint: string, options?: RequestOptions & {
+        params?: Record<string, any>;
+    }): Promise<SazitoResponse<T>>;
+    /**
+     * POST request
+     */
+    post<T>(endpoint: string, body?: any, options?: RequestOptions): Promise<SazitoResponse<T>>;
+    /**
+     * PUT request
+     */
+    put<T>(endpoint: string, body?: any, options?: RequestOptions): Promise<SazitoResponse<T>>;
+    /**
+     * DELETE request
+     */
+    delete<T>(endpoint: string, options?: RequestOptions): Promise<SazitoResponse<T>>;
+    /**
+     * Core request method
+     */
+    private request;
+    /**
+     * Build full URL with query params
+     */
+    private buildUrl;
+    /**
+     * Get request headers
+     */
+    private getHeaders;
+    /**
+     * Check if status code should trigger a retry
+     */
+    private shouldRetry;
+    /**
+     * Delay helper for retries
+     */
+    private delay;
+    /**
+     * Extract API name from endpoint for cache management
+     */
+    private getApiName;
+    /**
+     * Get token storage instance
+     */
+    getTokenStorage(): TokenStorage;
+    /**
+     * Clear all cache
+     */
+    clearCache(): void;
+}
+
+/**
+ * Products API
+ */
+
+declare class ProductsAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Map SDK sort values to API sort values
+     */
+    private mapSortToApi;
+    /**
+     * Transform filters to API request params
+     */
+    private transformFilters;
+    /**
+     * Get a single product by slug or URL path
+     * Uses the entity route API to resolve the product
+     */
+    get(slugOrPath: string, options?: RequestOptions): Promise<SazitoResponse<Product>>;
+    /**
+     * List products with filters
+     */
+    list(filters?: ProductFilters, options?: RequestOptions): Promise<SazitoResponse<PaginatedResponse<Product>>>;
+    /**
+     * Search across all entity types (products, blog pages, CMS pages, product categories)
+     */
+    search(query: string, filters?: ProductFilters, options?: RequestOptions): Promise<SazitoResponse<SearchResponse>>;
+}
+
+/**
+ * Categories API
+ */
+
+/**
+ * Category tree node structure
+ */
+interface CategoryTreeNode {
+    id: number;
+    entityType: 'product_category';
+    entityId: number;
+    entity: ProductCategory;
+    details: any;
+    children: CategoryTreeNode[];
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Category tree structure
+ */
+interface CategoryTree {
+    id: number;
+    treeType: 'product_categories';
+    treeStructure: {
+        nodes: CategoryTreeNode[];
+    };
+}
+/**
+ * Category list response with hierarchical tree
+ */
+interface CategoryListResponse {
+    categories: ProductCategory[];
+    tree: CategoryTree;
+}
+/**
+ * Category list filters
+ */
+interface CategoryFilters {
+    page?: number;
+    pageSize?: number;
+}
+declare class CategoriesAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get a single category by ID or slug
+     */
+    get(idOrSlug: string | number, options?: RequestOptions): Promise<SazitoResponse<ProductCategory>>;
+    /**
+     * List all categories with hierarchical tree structure
+     * @param filters Optional pagination filters
+     * @param options Additional request options
+     */
+    list(filters?: CategoryFilters, options?: RequestOptions): Promise<SazitoResponse<CategoryListResponse>>;
+}
+
+/**
+ * Credentials Manager for guest users
+ * Manages cart, invoice, shipping, and payment credentials in localStorage
+ */
+
+declare class CredentialsManager {
+    private readonly CART_KEY;
+    private readonly INVOICE_KEY;
+    private readonly SHIPPING_KEY;
+    private readonly PAYMENT_KEY;
+    private readonly DISCOUNT_KEY;
+    /**
+     * Cart Credentials
+     */
+    getCartCredentials(): CartCredentials | null;
+    setCartCredentials(credentials: CartCredentials): void;
+    clearCartCredentials(): void;
+    /**
+     * Invoice Credentials
+     */
+    getInvoiceCredentials(): InvoiceCredentials | null;
+    setInvoiceCredentials(credentials: InvoiceCredentials): void;
+    clearInvoiceCredentials(): void;
+    /**
+     * Shipping Address Credentials
+     */
+    getShippingCredentials(): ShippingAddressCredentials | null;
+    setShippingCredentials(credentials: ShippingAddressCredentials): void;
+    clearShippingCredentials(): void;
+    /**
+     * Payment Credentials
+     */
+    getPaymentCredentials(): PaymentCredentials | null;
+    setPaymentCredentials(credentials: PaymentCredentials): void;
+    clearPaymentCredentials(): void;
+    /**
+     * Discount Code
+     */
+    getDiscountCode(): string | null;
+    setDiscountCode(code: string): void;
+    clearDiscountCode(): void;
+    /**
+     * Clear all credentials
+     */
+    clearAll(): void;
+    /**
+     * Get item from localStorage
+     */
+    private getItem;
+    /**
+     * Set item in localStorage
+     */
+    private setItem;
+    /**
+     * Remove item from localStorage
+     */
+    private removeItem;
+}
+
+/**
+ * Cart API
+ * Supports both authenticated and guest users via credentials
+ */
+
+declare class CartAPI {
+    private http;
+    private credentials;
+    constructor(http: HttpClient, credentials: CredentialsManager);
+    /**
+     * Get current cart
+     */
+    get(options?: RequestOptions): Promise<SazitoResponse<Cart>>;
+    /**
+     * Create a new cart
+     */
+    create(input: CreateCartInput, options?: RequestOptions): Promise<SazitoResponse<Cart>>;
+    /**
+     * Add item to cart
+     */
+    addItem(variantId: number, count: number, formAttributes?: Record<string, any>, options?: RequestOptions): Promise<SazitoResponse<Cart>>;
+    /**
+     * Update cart item quantity
+     */
+    updateItem(cartProductId: number, count: number, options?: RequestOptions): Promise<SazitoResponse<Cart>>;
+    /**
+     * Remove item from cart
+     */
+    removeItem(cartProductId: number, variantId: number, options?: RequestOptions): Promise<SazitoResponse<Cart>>;
+    /**
+     * Clear current cart credentials
+     */
+    clearCart(): void;
+}
+
+/**
+ * Orders API
+ * Requires authentication
+ */
+
+declare class OrdersAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List orders (requires authentication)
+     */
+    list(filters?: OrderFilters, options?: RequestOptions): Promise<SazitoResponse<PaginatedResponse<Order>>>;
+    /**
+     * Get single order by ID (requires authentication)
+     */
+    get(orderId: number, options?: RequestOptions): Promise<SazitoResponse<Order>>;
+}
+
+/**
+ * Invoices API (Checkout)
+ */
+
+declare class InvoicesAPI {
+    private http;
+    private credentials;
+    constructor(http: HttpClient, credentials: CredentialsManager);
+    /**
+     * Get current invoice
+     */
+    get(options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Create a new invoice from cart
+     */
+    create(options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Refresh invoice (sync with cart)
+     */
+    refresh(options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Add shipping address to invoice
+     */
+    addShippingAddress(shippingAddressId: number, shippingAddressIdentifier: string, options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Add discount code to invoice
+     */
+    addDiscountCode(code: string, options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Assign shipping method to invoice
+     */
+    assignShippingMethod(shippings: ShippingAssignment[], options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Add invoice details (user comment)
+     */
+    addDetails(comment: string, options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Get applicable shipping methods for invoice
+     */
+    getApplicableShippingMethods(options?: RequestOptions): Promise<SazitoResponse<ShippingMethod[]>>;
+    /**
+     * Clear current invoice credentials
+     */
+    clearInvoice(): void;
+}
+
+/**
+ * Shipping API (Addresses and Methods)
+ */
+
+declare class ShippingAPI {
+    private http;
+    private credentials;
+    constructor(http: HttpClient, credentials: CredentialsManager);
+    /**
+     * Create shipping address
+     */
+    createAddress(address: ShippingAddressInput, options?: RequestOptions): Promise<SazitoResponse<ShippingAddress>>;
+    /**
+     * Update shipping address
+     */
+    updateAddress(address: ShippingAddressInput, options?: RequestOptions): Promise<SazitoResponse<ShippingAddress>>;
+    /**
+     * Get shipping address
+     */
+    getAddress(options?: RequestOptions): Promise<SazitoResponse<ShippingAddress>>;
+    /**
+     * Get list of enabled shipping methods
+     */
+    getMethods(options?: RequestOptions): Promise<SazitoResponse<ShippingMethod[]>>;
+    /**
+     * Clear shipping address credentials
+     */
+    clearAddress(): void;
+}
+
+/**
+ * Payments API
+ */
+
+declare class PaymentsAPI {
+    private http;
+    private credentials;
+    constructor(http: HttpClient, credentials: CredentialsManager);
+    /**
+     * Get list of payment methods for invoice
+     */
+    getMethods(options?: RequestOptions): Promise<SazitoResponse<PaymentMethod[]>>;
+    /**
+     * Create payment
+     */
+    create(paymentTypeId: number, options?: RequestOptions): Promise<SazitoResponse<Payment>>;
+    /**
+     * Initialize payment (get payment action)
+     */
+    initialize(options?: RequestOptions): Promise<SazitoResponse<PaymentAction>>;
+    /**
+     * Process payment step (for card-to-card or multi-step payments)
+     */
+    processStep(input: PaymentStepInput, options?: RequestOptions): Promise<SazitoResponse<any>>;
+    /**
+     * Clear payment credentials
+     */
+    clearPayment(): void;
+}
+
+/**
+ * Users API (Authentication and user management)
+ */
+
+/**
+ * Login input (SDK uses camelCase)
+ */
+interface LoginInput {
+    email: string;
+    password: string;
+}
+/**
+ * Register input (SDK uses camelCase)
+ */
+interface RegisterInput {
+    email: string;
+    password: string;
+    passwordConfirmation: string;
+    firstName?: string;
+    lastName?: string;
+    mobilePhone?: string;
+}
+/**
+ * Mobile login input
+ */
+interface MobileLoginInput {
+    mobilePhone: string;
+}
+/**
+ * Verify mobile OTP input (SDK uses camelCase)
+ */
+interface VerifyMobileInput {
+    mobilePhone: string;
+    token: string;
+}
+/**
+ * Passwordless email login input
+ */
+interface EmailLoginRequestInput {
+    email: string;
+}
+/**
+ * Forgot password input
+ */
+interface ForgotPasswordInput {
+    email: string;
+}
+/**
+ * Reset password input (SDK uses camelCase)
+ */
+interface ResetPasswordInput {
+    forgotPasswordToken: string;
+    password: string;
+    passwordConfirmation: string;
+}
+/**
+ * Update user profile input
+ */
+interface UpdateProfileInput {
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    password?: string;
+    passwordConfirmation?: string;
+    birthDate?: string;
+}
+/**
+ * Update user phone request input
+ */
+interface UpdateMobilePhoneRequestInput {
+    mobilePhone: string;
+}
+/**
+ * Verify user phone update input
+ */
+interface UpdateMobilePhoneVerificationInput {
+    mobilePhone: string;
+    token: string;
+}
+interface LoginResponse {
+    jwt: string;
+    user?: User;
+}
+declare class UsersAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Login with email and password
+     */
+    login(input: LoginInput, options?: RequestOptions): Promise<SazitoResponse<LoginResponse>>;
+    /**
+     * Request mobile OTP
+     */
+    requestMobileOTP(input: MobileLoginInput, options?: RequestOptions): Promise<SazitoResponse<any>>;
+    /**
+     * Verify mobile OTP
+     */
+    verifyMobileOTP(input: VerifyMobileInput, options?: RequestOptions): Promise<SazitoResponse<LoginResponse>>;
+    /**
+     * Passwordless login request via email
+     */
+    requestEmailLogin(input: EmailLoginRequestInput, options?: RequestOptions): Promise<SazitoResponse<any>>;
+    /**
+     * Register new user
+     */
+    register(input: RegisterInput, options?: RequestOptions): Promise<SazitoResponse<User>>;
+    /**
+     * Get current user (requires authentication)
+     */
+    getCurrentUser(options?: RequestOptions): Promise<SazitoResponse<User>>;
+    /**
+     * Update user profile (requires authentication)
+     */
+    updateProfile(userId: number, data: UpdateProfileInput, options?: RequestOptions): Promise<SazitoResponse<User>>;
+    /**
+     * Request mobile phone update (requires authentication)
+     */
+    requestMobilePhoneUpdate(input: UpdateMobilePhoneRequestInput, options?: RequestOptions): Promise<SazitoResponse<any>>;
+    /**
+     * Verify mobile phone update (requires authentication)
+     */
+    verifyMobilePhoneUpdate(input: UpdateMobilePhoneVerificationInput, options?: RequestOptions): Promise<SazitoResponse<User>>;
+    /**
+     * Forgot password - send reset email
+     */
+    forgotPassword(input: ForgotPasswordInput, options?: RequestOptions): Promise<SazitoResponse<any>>;
+    /**
+     * Revive/Reset password with token
+     */
+    revivePassword(input: ResetPasswordInput, options?: RequestOptions): Promise<SazitoResponse<LoginResponse>>;
+    /**
+     * Merge guest and current user accounts after login
+     */
+    mergeUser(options?: RequestOptions): Promise<SazitoResponse<any>>;
+}
+
+/**
+ * Search API
+ */
+
+interface SearchFilters {
+    page?: number;
+    pageSize?: number;
+    categoryId?: number;
+    minPrice?: number;
+    maxPrice?: number;
+}
+declare class SearchAPI {
+    private http;
+    constructor(http: HttpClient);
+    private transformFilters;
+    /**
+     * Query across multiple entity types (products, blog pages, CMS pages, categories)
+     */
+    query(term: string, filters?: SearchFilters, options?: RequestOptions): Promise<SazitoResponse<SearchResponse>>;
+}
+
+/**
+ * Feedbacks API (Comments and reviews)
+ */
+
+interface Feedback {
+    id: number;
+    user?: {
+        id: number;
+        name: string;
+    };
+    productId?: number;
+    rating?: number;
+    comment: string;
+    status: 'pending' | 'approved' | 'rejected';
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateFeedbackInput {
+    productId?: number;
+    rating?: number;
+    comment: string;
+}
+interface FeedbackFilters {
+    productId?: number;
+    page?: number;
+    pageSize?: number;
+}
+declare class FeedbacksAPI {
+    private http;
+    constructor(http: HttpClient);
+    private transformFilters;
+    /**
+     * List feedbacks
+     */
+    list(filters?: FeedbackFilters, options?: RequestOptions): Promise<SazitoResponse<PaginatedResponse<Feedback>>>;
+    /**
+     * Create feedback/review
+     */
+    create(input: CreateFeedbackInput, options?: RequestOptions): Promise<SazitoResponse<Feedback>>;
+    /**
+     * Get single feedback
+     */
+    get(feedbackId: number, options?: RequestOptions): Promise<SazitoResponse<Feedback>>;
+}
+
+/**
+ * Wallet API (User wallet and transactions)
+ */
+
+type WalletTransactionReason = 'redeem' | 'NthPurchase' | 'merge-user' | 'SimpleCashbackRule' | 'BirthdateGift' | 'TajrobehAppreciation' | 'edit_order' | 'cancel_order' | 'edit_shipping_cost' | 'edit_cashback' | 'gift' | 'others' | 'Refund' | 'Charge' | 'Expired' | `${string}:activity`;
+interface WalletTransaction {
+    id: string | number;
+    reason: WalletTransactionReason;
+    amount: number;
+    createdAt: string;
+    metaData?: Record<string, unknown>;
+}
+interface WalletBalance {
+    balance: number;
+    enabled: boolean;
+}
+interface Wallet extends WalletBalance {
+    currency?: string;
+    transactions?: WalletTransaction[];
+}
+interface TransactionFilters {
+    page_number?: number;
+    page_size?: number;
+}
+interface WalletTransactionsResponse {
+    transactions: WalletTransaction[];
+}
+declare class WalletAPI {
+    private http;
+    constructor(http: HttpClient);
+    private validateInvoiceId;
+    /**
+     * Get wallet balance (requires authentication)
+     */
+    getBalance(options?: RequestOptions): Promise<SazitoResponse<Wallet>>;
+    /**
+     * List wallet transactions (requires authentication)
+     */
+    listTransactions(filters?: TransactionFilters, options?: RequestOptions): Promise<SazitoResponse<WalletTransactionsResponse>>;
+    /**
+     * Apply wallet credit on an invoice (requires authentication)
+     */
+    applyCredit(invoiceId: number, options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Remove wallet credit from an invoice (requires authentication)
+     */
+    removeCredit(invoiceId: number, options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+}
+
+/**
+ * CMS API (Content Management - Pages, Blogs, etc.)
+ */
+
+/**
+ * CMS Page type (re-exported from search types for convenience)
+ * Both regular pages and blog posts use this structure
+ */
+type CMSPage = CmsPage;
+
+/**
+ * Filters for CMS pages list
+ * Backend uses: page_number, page_size, filters[]
+ */
+interface CMSFilters {
+    page?: number;
+    pageSize?: number;
+    cmsPageTypes?: CMSPageType | CMSPageType[];
+}
+declare class CMSAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get CMS page by URL path
+     * Uses entity routes API (recommended approach)
+     * @param urlPath - Page URL path (e.g., '/about-us')
+     * @param options - Request options
+     */
+    getPage(urlPath: string, options?: RequestOptions): Promise<SazitoResponse<CMSPage>>;
+    /**
+     * List CMS pages (excludes blog posts)
+     * @param filters - Filter options (will automatically exclude blog type)
+     * @param options - Request options
+     */
+    listPages(filters?: CMSFilters, options?: RequestOptions): Promise<SazitoResponse<PaginatedResponse<CMSPage>>>;
+    /**
+     * Get blog post by URL path
+     * Uses entity routes API (recommended approach)
+     * @param urlPath - Blog post URL path (e.g., '/blog/my-post')
+     * @param options - Request options
+     */
+    getBlogPost(urlPath: string, options?: RequestOptions): Promise<SazitoResponse<CMSPage>>;
+    /**
+     * List blog posts
+     * @param filters - Filter options (will automatically filter for blog type)
+     * @param options - Request options
+     */
+    listBlogPosts(filters?: CMSFilters, options?: RequestOptions): Promise<SazitoResponse<PaginatedResponse<CMSPage>>>;
+    /**
+     * List all CMS content (both pages and blog posts)
+     * @param filters - Filter options
+     * @param options - Request options
+     */
+    listAll(filters?: CMSFilters, options?: RequestOptions): Promise<SazitoResponse<PaginatedResponse<CMSPage>>>;
+}
+
+/**
+ * Images API (File upload)
+ */
+
+interface UploadImageResponse {
+    id: number;
+    url: string;
+    filename: string;
+    size: number;
+    mime_type: string;
+}
+declare class ImagesAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Upload image file
+     * @param file - File or Blob to upload
+     */
+    upload(file: File | Blob, options?: RequestOptions): Promise<SazitoResponse<UploadImageResponse>>;
+    /**
+     * Delete image
+     */
+    delete(imageId: number, options?: RequestOptions): Promise<SazitoResponse<void>>;
+}
+
+/**
+ * Visits API (Analytics and page views)
+ */
+
+/**
+ * Visit tracking input (SDK uses camelCase)
+ */
+interface VisitInput {
+    url: string;
+    referrer?: string;
+    userAgent?: string;
+    entityType?: 'product' | 'category' | 'page';
+    entityId?: number;
+}
+/**
+ * Visit tracking response (auto-transformed to camelCase by HTTP client)
+ */
+interface VisitResponse {
+    id: number;
+    createdAt: string;
+}
+declare class VisitsAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Track visit analytics event.
+     * Backend endpoint `/api/v1/visits/add` does not accept a payload.
+     */
+    track(inputOrOptions?: VisitInput | RequestOptions, options?: RequestOptions): Promise<SazitoResponse<VisitResponse>>;
+    /**
+     * Track product view
+     */
+    trackProduct(productId: number, url: string, options?: RequestOptions): Promise<SazitoResponse<VisitResponse>>;
+    /**
+     * Track category view
+     */
+    trackCategory(categoryId: number, url: string, options?: RequestOptions): Promise<SazitoResponse<VisitResponse>>;
+}
+
+/**
+ * Booking API (Event scheduling and appointments)
+ */
+
+interface Event {
+    id: number;
+    title: string;
+    description?: string;
+    start_time: string;
+    end_time: string;
+    capacity: number;
+    booked_count: number;
+    available_slots: number;
+    price?: number;
+    location?: string;
+    created_at: string;
+}
+interface Booking {
+    id: number;
+    event_id: number;
+    event: Event;
+    user_id?: number;
+    attendee_name: string;
+    attendee_email?: string;
+    attendee_phone?: string;
+    status: 'pending' | 'confirmed' | 'cancelled';
+    booking_time: string;
+    created_at: string;
+}
+interface CreateBookingInput {
+    event_entity_id: number;
+    timezone: string;
+    attendee_name: string;
+    attendee_email?: string;
+    attendee_phone?: string;
+}
+interface EventFilters {
+    start_date?: string;
+    end_date?: string;
+    available_only?: boolean;
+    page?: number;
+    page_size?: number;
+}
+declare class BookingAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List available events
+     */
+    listEvents(filters?: EventFilters, options?: RequestOptions): Promise<SazitoResponse<PaginatedResponse<Event>>>;
+    /**
+     * Get single event
+     */
+    getEvent(eventId: number, options?: RequestOptions): Promise<SazitoResponse<Event>>;
+    /**
+     * Create booking
+     */
+    createBooking(input: CreateBookingInput, options?: RequestOptions): Promise<SazitoResponse<Booking>>;
+    /**
+     * List user bookings (requires authentication)
+     */
+    listBookings(options?: RequestOptions): Promise<SazitoResponse<PaginatedResponse<Booking>>>;
+    /**
+     * Cancel booking
+     */
+    cancelBooking(bookingId: number, options?: RequestOptions): Promise<SazitoResponse<Booking>>;
+}
+
+/**
+ * Entity Routes API
+ * Resolves URLs to entity data (products, categories, CMS pages)
+ */
+
+declare class EntityRoutesAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Resolve URL path to entity data
+     * @param urlPart - URL pathname (e.g., '/product/laptop-abc' or '/category/electronics')
+     * @returns Entity route with cleaned entity data based on type
+     */
+    resolve(urlPart: string, options?: RequestOptions): Promise<SazitoResponse<EntityRouteResponse>>;
+}
+
+/**
+ * Menu API (Header Menu, Navigation Trees)
+ */
+
+declare class MenuAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Fetch header menu by identifier
+     * @param identifier - Menu identifier (default: 'headermenu')
+     * @param options - Request options
+     */
+    getHeaderMenu(identifier?: string, options?: RequestOptions): Promise<SazitoResponse<MenuItem[]>>;
+    /**
+     * Convert raw tree structure to clean navigation items
+     * Filters out disabled items and processes nested children recursively
+     */
+    private convertRawTreeToNavigation;
+    /**
+     * Extract the display title for a menu node
+     */
+    private findNodeTitle;
+    /**
+     * Extract the URL for a menu node
+     */
+    private findNodeUrl;
+    /**
+     * Determine if a node should be filtered out (disabled items)
+     */
+    private shouldDropNode;
+}
+
+/**
+ * General API (shop configuration and feature flags)
+ */
+
+interface Region {
+    id: number;
+    name: string;
+    latitude: number;
+    longitude: number;
+}
+interface City {
+    id: number;
+    name: string;
+    latitude: number;
+    longitude: number;
+    region: Region;
+}
+interface PremiumInfo {
+    enabled: boolean;
+    nextRenewal: string;
+    subscriptionSubtype: string;
+}
+interface GoogleAnalyticsCode {
+    code: string;
+    enabled: boolean;
+}
+interface GoogleInfo {
+    analyticsCode: GoogleAnalyticsCode;
+    analyticsId: GoogleAnalyticsCode;
+    tagManager: GoogleAnalyticsCode;
+}
+interface LogoInfo {
+    favicon: string;
+    main: string;
+}
+interface SocialInfo {
+    facebook: string;
+    instagram: string;
+    phone1: string;
+    phone2: string;
+    telegram: string;
+    twitter: string;
+    whatsapp: string;
+}
+interface DomainInfo {
+    url: string;
+}
+interface EnamadInfo {
+    code: string;
+}
+interface ShopInfo {
+    name: string;
+    description: string;
+    city: City | null;
+    domain: DomainInfo;
+    logo: LogoInfo;
+    social: SocialInfo;
+}
+interface CheckoutConfig {
+    addToCartAlert: boolean;
+    dynamicForm: boolean;
+    emailOptional: boolean;
+    preventRedirect: boolean;
+    minBasket: {
+        enabled: boolean;
+        minAmount: number;
+    };
+    miniCart: boolean;
+    postalCodeMandatory: boolean;
+    quickAddToCart: boolean;
+}
+interface TajrobeConfig {
+    enabled: boolean;
+}
+interface WalletConfig {
+    enabled: boolean;
+    useWithDiscount: boolean;
+    minAmount: number;
+    minAmountRequired: boolean;
+}
+/**
+ * Standardized feature shape:
+ * - boolean feature switches as direct keys on the object
+ * - premium details in `premium`
+ */
+interface ShopFeatures {
+    [featureName: string]: boolean | PremiumInfo | undefined;
+    premium?: PremiumInfo;
+}
+interface ScriptsInfo {
+    enamad: EnamadInfo;
+    google: GoogleInfo;
+}
+interface SettingsInfo {
+    checkout: CheckoutConfig;
+    features: ShopFeatures;
+    wallet: WalletConfig;
+    tajrobe: TajrobeConfig;
+    registerType: string;
+    showProductStockNumber: boolean;
+}
+/**
+ * Standardized General API response
+ */
+interface GeneralInfo {
+    shop: ShopInfo;
+    settings: SettingsInfo;
+    scripts: ScriptsInfo;
+}
+declare class GeneralAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get normalized shop information including config and features.
+     */
+    getInfo(options?: RequestOptions): Promise<SazitoResponse<GeneralInfo>>;
+    /**
+     * Get standardized shop feature flags only.
+     */
+    getFeatures(options?: RequestOptions): Promise<SazitoResponse<ShopFeatures>>;
+    /**
+     * Get standardized checkout config only.
+     */
+    getCheckoutConfig(options?: RequestOptions): Promise<SazitoResponse<CheckoutConfig>>;
+    /**
+     * Get standardized wallet config only.
+     */
+    getWalletConfig(options?: RequestOptions): Promise<SazitoResponse<WalletConfig>>;
+    /**
+     * Get standardized Tajrobe config only.
+     */
+    getTajrobeConfig(options?: RequestOptions): Promise<SazitoResponse<TajrobeConfig>>;
+}
+
+/**
+ * Main Sazito SDK Client
+ */
+
+declare class SazitoClient {
+    private http;
+    private tokenStorage;
+    private credentialsManager;
+    readonly products: ProductsAPI;
+    readonly categories: CategoriesAPI;
+    readonly cart: CartAPI;
+    readonly orders: OrdersAPI;
+    readonly invoices: InvoicesAPI;
+    readonly shipping: ShippingAPI;
+    readonly payments: PaymentsAPI;
+    readonly users: UsersAPI;
+    readonly search: SearchAPI;
+    readonly feedbacks: FeedbacksAPI;
+    readonly wallet: WalletAPI;
+    readonly cms: CMSAPI;
+    readonly images: ImagesAPI;
+    readonly visits: VisitsAPI;
+    readonly booking: BookingAPI;
+    readonly entityRoutes: EntityRoutesAPI;
+    readonly menu: MenuAPI;
+    readonly general: GeneralAPI;
+    constructor(config: SazitoConfig);
+    /**
+     * Set authentication token (stored in localStorage with cookie fallback)
+     */
+    setAuthToken(token: string): void;
+    /**
+     * Get authentication token from storage
+     */
+    getAuthToken(): string | null;
+    /**
+     * Clear authentication token
+     */
+    clearAuth(): void;
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Clear all cache
+     */
+    clearCache(): void;
+    /**
+     * Clear all guest credentials
+     */
+    clearCredentials(): void;
+    /**
+     * Clear everything (auth + cache + credentials)
+     */
+    clearAll(): void;
+    /**
+     * Search helper for `client.search.query(...)`.
+     */
+    searchQuery(query: string, filters?: SearchFilters, options?: RequestOptions): Promise<SazitoResponse<SearchResponse>>;
+}
+/**
+ * Create a new Sazito SDK client instance
+ */
+declare function createSazitoClient(config: SazitoConfig): SazitoClient;
+
+interface ModuleContext {
+    http: HttpClient;
+    credentials: CredentialsManager;
+}
+
+declare function createProductsAPI(configOrContext: SazitoConfig | ModuleContext): ProductsAPI;
+
+declare function createCategoriesAPI(configOrContext: SazitoConfig | ModuleContext): CategoriesAPI;
+
+declare function createCartAPI(configOrContext: SazitoConfig | ModuleContext): CartAPI;
+
+declare function createOrdersAPI(configOrContext: SazitoConfig | ModuleContext): OrdersAPI;
+
+declare function createInvoicesAPI(configOrContext: SazitoConfig | ModuleContext): InvoicesAPI;
+
+declare function createShippingAPI(configOrContext: SazitoConfig | ModuleContext): ShippingAPI;
+
+declare function createPaymentsAPI(configOrContext: SazitoConfig | ModuleContext): PaymentsAPI;
+
+declare function createUsersAPI(configOrContext: SazitoConfig | ModuleContext): UsersAPI;
+
+declare function createSearchAPI(configOrContext: SazitoConfig | ModuleContext): SearchAPI;
+
+declare function createFeedbacksAPI(configOrContext: SazitoConfig | ModuleContext): FeedbacksAPI;
+
+declare function createWalletAPI(configOrContext: SazitoConfig | ModuleContext): WalletAPI;
+
+declare function createCMSAPI(configOrContext: SazitoConfig | ModuleContext): CMSAPI;
+
+declare function createImagesAPI(configOrContext: SazitoConfig | ModuleContext): ImagesAPI;
+
+declare function createVisitsAPI(configOrContext: SazitoConfig | ModuleContext): VisitsAPI;
+
+declare function createBookingAPI(configOrContext: SazitoConfig | ModuleContext): BookingAPI;
+
+declare function createEntityRoutesAPI(configOrContext: SazitoConfig | ModuleContext): EntityRoutesAPI;
+
+declare function createMenuAPI(configOrContext: SazitoConfig | ModuleContext): MenuAPI;
+
+declare function createGeneralAPI(configOrContext: SazitoConfig | ModuleContext): GeneralAPI;
+
+/**
+ * API Data Transformers
+ * Convert between SDK-friendly camelCase and backend snake_case
+ */
+/**
+ * Transform object keys from snake_case to camelCase with field name beautification
+ * @param obj - Object to transform
+ * @returns Transformed object with camelCase keys and beautiful field names
+ */
+declare function transformResponseKeys(obj: any): any;
+/**
+ * Transform object keys from camelCase to snake_case for API requests
+ * @param obj - Object to transform
+ * @returns Transformed object with snake_case keys
+ */
+declare function transformRequestKeys(obj: any): any;
+/**
+ * Transform API response data structure
+ * Unwraps the { data: { result: { ... } } } structure and transforms keys
+ */
+declare function transformApiResponse<T = any>(response: any): T;
+/**
+ * Specific transformer for cart responses
+ * Handles the cart-specific data structure
+ */
+declare function transformCartResponse(response: any): any;
+/**
+ * Specific transformer for invoice responses
+ * Handles the invoice-specific data structure
+ */
+declare function transformInvoiceResponse(response: any): any;
+/**
+ * Specific transformer for product list responses
+ * Handles paginated product lists
+ */
+declare function transformProductListResponse(response: any): any;
+/**
+ * Transform shipping address input for API request
+ */
+declare function transformShippingAddressInput(input: any): any;
+/**
+ * Transform add to cart input for API request
+ */
+declare function transformAddToCartInput(variantId: number, quantity: number, formAttributes?: any): any;
+/**
+ * Transform create cart input for API request
+ */
+declare function transformCreateCartInput(input: any): any;
+
+export { CredentialsManager, HttpClient, SazitoClient, TokenStorage, createBookingAPI as booking, createCartAPI as cart, createCategoriesAPI as categories, createCMSAPI as cms, createBookingAPI, createCMSAPI, createCartAPI, createCategoriesAPI, createEntityRoutesAPI, createFeedbacksAPI, createGeneralAPI, createImagesAPI, createInvoicesAPI, createMenuAPI, createOrdersAPI, createPaymentsAPI, createProductsAPI, createSazitoClient, createSearchAPI, createShippingAPI, createUsersAPI, createVisitsAPI, createWalletAPI, createEntityRoutesAPI as entityRoutes, createFeedbacksAPI as feedbacks, createGeneralAPI as general, createImagesAPI as images, createInvoicesAPI as invoices, createMenuAPI as menu, createOrdersAPI as orders, createPaymentsAPI as payments, createProductsAPI as products, createSearchAPI as search, createShippingAPI as shipping, transformAddToCartInput, transformApiResponse, transformCartResponse, transformCreateCartInput, transformInvoiceResponse, transformProductListResponse, transformRequestKeys, transformResponseKeys, transformShippingAddressInput, createUsersAPI as users, createVisitsAPI as visits, createWalletAPI as wallet };
+export type { AddToCartInput, BlogPage, BlogPageEntityRoute, CMSPageEntityRoute, CMSPageType, CacheConfig, Cart, CartCredentials, CartProduct, City$1 as City, CmsPage, CookieOptions, CreateCartInput, CreateInvoiceInput, CreatePaymentInput, EntityRoute, EntityRouteResponse, EntityType, Image, Invoice, InvoiceCredentials, InvoiceItem, MenuItem, MenuNode, MenuTree, Order, OrderFilters, OrderStatus, PaginatedResponse, Payment, PaymentAction, PaymentCredentials, PaymentGateway, PaymentMethod, PaymentStatus, PaymentStepInput, Product, ProductAttribute, ProductCategory, ProductCategoryEntityRoute, ProductEntityRoute, ProductFilters, ProductSort, ProductVariant, RefreshInvoiceInput, Region$1 as Region, RequestOptions, RetryConfig, SazitoConfig, SazitoResponse, SearchFilters, SearchResponse, ShippingAddress, ShippingAddressCredentials, ShippingAddressInput, ShippingAssignment, ShippingItem, ShippingMethod, ShippingRate, Tag, UnknownEntityRoute, User };