@sazito/client-sdk 1.2.2 → 1.2.4

package/dist/index.d.mts

@@ -0,0 +1,2289 @@
+/**
+ * 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
+ */
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+interface JsonObject {
+    [key: string]: JsonValue;
+}
+type JsonArray = JsonValue[];
+/**
+ * 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?: JsonValue;
+    };
+}
+/**
+ * Paginated response wrapper
+ */
+interface PaginatedResponse<T> {
+    items: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+/**
+ * Request options that can be passed to an API call
+ */
+interface RequestOptions {
+    retries?: number;
+    timeout?: number;
+    cache?: boolean;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    skipTransform?: boolean;
+}
+/**
+ * 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;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Product attribute (e.g., color, size)
+ */
+/**
+ * Rich attribute value for typed fields like color swatches.
+ * `value` is the human-readable label; `extra` carries the payload
+ * (e.g. a hex color when `fieldType` is `'color'`).
+ */
+interface ProductAttributeValueObject {
+    value: string;
+    extra?: string;
+    fieldType?: string;
+}
+interface ProductAttribute {
+    name: string;
+    value: string | ProductAttributeValueObject;
+}
+/**
+ * Normalized product snapshot embedded in checkout entities
+ * (cart items, invoice items, successful order items).
+ */
+interface CheckoutProductSnapshot {
+    variantId: number;
+    productId?: number;
+    name: string;
+    url?: string;
+    image?: Image;
+    attributes: ProductAttribute[];
+    productType?: string;
+    hasMaxOrder?: boolean;
+    maxOrderQuantity?: number;
+    minOrderQuantity?: number;
+}
+/**
+ * Region (استان)
+ */
+interface Region$1 {
+    id: number;
+    name: string;
+    cities?: City$1[];
+}
+/**
+ * City (شهر)
+ */
+interface City$1 {
+    id: number;
+    name: string;
+    regionId?: number;
+    latitude?: number;
+    longitude?: 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?: JsonValue[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface Product {
+    id?: number;
+    name: string;
+    url: string;
+    enabled: boolean;
+    productType: string;
+    themeConfig?: JsonObject;
+    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?: JsonObject;
+    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 SchedulerBookingAttributes {
+    eventEntityId: string | number;
+    eventTitle?: string;
+    eventId?: string;
+    startDateTimeLocal: string;
+    endDateTimeLocal: string;
+    timezone: string;
+}
+interface UploadedFormFileAttribute {
+    serveKey: string;
+    fileName: string;
+}
+type FormAttributeValue = string | number | boolean | null | UploadedFormFileAttribute;
+interface CartProduct {
+    id: number | string;
+    productVariantId: number;
+    quantity: number;
+    unitPrice: number;
+    lineTotal: number;
+    product: CheckoutProductSnapshot;
+    formAttributes?: Record<string, FormAttributeValue>;
+    formFields?: JsonObject;
+    bookingAttributes?: SchedulerBookingAttributes;
+}
+interface Cart {
+    id: number;
+    identifier: string;
+    items: CartProduct[];
+    netTotal: number;
+    grossTotal?: number;
+    needsShipping: boolean;
+    minBasketLimitViolated: boolean;
+    deleteCoupon?: boolean;
+}
+interface CartCredentials {
+    identifier: string;
+}
+interface AddToCartInput {
+    id: number;
+    count: number;
+    formAttributes?: Record<string, FormAttributeValue>;
+}
+interface CreateCartInput {
+    coupon?: string;
+    variants: AddToCartInput[];
+    formAttributes?: Record<string, FormAttributeValue>;
+    schedulerBookingAttributes?: SchedulerBookingAttributes;
+}
+
+/**
+ * Invoice and checkout-related types
+ */
+
+interface InvoiceItemFormAttributes {
+    formId?: number;
+    formData: Record<string, {
+        label: string;
+        value: JsonValue;
+        type: string;
+    }>;
+}
+interface InvoiceItem {
+    id: number | string;
+    productVariantId: number;
+    productId?: number;
+    name: string;
+    url?: string;
+    attributes: ProductAttribute[];
+    productType?: string;
+    hasMaxOrder?: boolean;
+    maxOrderQuantity?: number;
+    minOrderQuantity?: number;
+    image?: Image;
+    quantity: number;
+    unitPrice: number;
+    lineTotal: number;
+    rawPrice: number;
+    customerProfit: number;
+    commercialFiles?: JsonValue;
+    formAttributes?: Record<string, FormAttributeValue> | InvoiceItemFormAttributes;
+    bookingAttributes?: SchedulerBookingAttributes;
+    formFields?: JsonObject;
+}
+interface ShippingItem {
+    invoiceItemIds: Array<number | string>;
+    rate: {
+        id: number;
+        name: string;
+        price: number;
+        icon?: string;
+        color?: string;
+        type?: string;
+    };
+}
+interface ShippingAddressRegion {
+    id: number;
+    name: string;
+}
+interface ShippingAddressCity {
+    id: number;
+    name: string;
+    regionId?: number;
+    latitude?: number;
+    longitude?: number;
+}
+interface ShippingAddress {
+    id: number;
+    identifier: string;
+    firstName: string;
+    lastName: string;
+    mobilePhone?: string;
+    phoneNumber?: string;
+    email?: string;
+    region?: ShippingAddressRegion;
+    city: ShippingAddressCity;
+    address: string;
+    postalCode?: string;
+    description?: string;
+    latitude?: number;
+    longitude?: number;
+    userSetCoordinatesBefore?: boolean;
+}
+interface InvoiceShippingAddressRegion extends ShippingAddressRegion {
+    city: ShippingAddressCity;
+}
+interface InvoiceShippingAddress {
+    identifier: string;
+    firstName: string;
+    lastName: string;
+    mobilePhone?: string;
+    phoneNumber?: string;
+    email?: string;
+    region?: InvoiceShippingAddressRegion;
+    address: string;
+    postalCode?: string;
+    description?: string;
+    latitude?: number;
+    longitude?: number;
+    userSetCoordinatesBefore?: boolean;
+}
+interface User {
+    id?: number;
+    email?: string;
+    mobilePhone?: string;
+    phoneNumber?: string;
+    firstName?: string;
+    lastName?: string;
+    birthDate?: string;
+}
+interface Invoice {
+    id: number;
+    identifier: string;
+    items: InvoiceItem[];
+    shippingAddress?: InvoiceShippingAddress;
+    shippingItems: ShippingItem[];
+    needsShipping: boolean;
+    userComment?: string;
+    netTotal: number;
+    finalTotal: number;
+    vat: number;
+    vatPercent: number;
+    itemsDiscount: number;
+    discountTotal: number;
+    customerProfit: number;
+    customerProfitPercentage: number;
+    itemsTotalRawPrice: number;
+    couponTotal: number;
+    shippingTotal: number;
+    creditTotal: number;
+    discountUsages: Array<{
+        discountCode: {
+            code: string;
+            userSegment?: string;
+        };
+    }>;
+    coupon?: {
+        userSegment?: string;
+    };
+    discountCode?: string;
+}
+interface InvoiceCredentials {
+    id: number;
+    identifier: string;
+}
+interface CreateInvoiceInput {
+    cartIdentifier: string;
+}
+interface RefreshInvoiceInput {
+    cartIdentifier: string;
+    identifier: string;
+}
+
+/**
+ * Shipping-related types
+ */
+interface ShippingMethod {
+    id: number;
+    name: string;
+    type: string;
+}
+interface ShippingRate {
+    id: number;
+    name: string;
+    price: number;
+    description?: string;
+    icon?: string;
+    color?: string;
+    type?: string;
+}
+interface ItemShippingRate {
+    invoiceItemId: number | string;
+    shippingRate: ShippingRate;
+}
+interface ApplicableShippingMethods {
+    shippingMethods: ShippingMethod[];
+    groupedShippingRates: Record<string, ShippingRate[]>;
+    itemsShippingRate: ItemShippingRate[];
+}
+interface ShippingAddressInput {
+    firstName: string;
+    lastName: string;
+    mobilePhone: string;
+    phoneNumber?: string;
+    email?: string;
+    regionId?: number;
+    cityId?: number;
+    address: string;
+    postalCode?: string;
+    description?: string;
+    latitude?: number;
+    longitude?: number;
+    showMap?: boolean;
+    userSetCoordinatesBefore?: boolean;
+}
+interface ShippingAddressCredentials {
+    id: number;
+    identifier: string;
+}
+interface ShippingAssignment {
+    rateId: number;
+    invoiceItemIds: Array<string | number>;
+}
+
+/**
+ * Order-related types
+ */
+
+interface Order {
+    id: number;
+    orderNumber: string;
+    orderIdentifier: string;
+    invoice: {
+        shippingItems: JsonObject[];
+        invoiceItems: InvoiceItem[];
+    };
+}
+interface OrdersListResponse {
+    orders: Order[];
+    totalCount: number;
+    totalCountRaw: number;
+    totalNotSeen: number;
+    totalSeen: number;
+}
+interface OrderFilters {
+    pageNumber?: number;
+    pageSize?: number;
+    filters?: Array<{
+        name: string;
+        value: JsonValue;
+    }>;
+}
+
+/**
+ * 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;
+    /** Backend display title (English). */
+    title: string;
+    /** Backend display title (Persian). */
+    titleFa: string;
+    /** Backend description; often null. */
+    description: string | null;
+    /** Backend payment sub-type id; null when not provided. */
+    paymentSubType: number | null;
+    /** Display order from backend. */
+    order: number;
+    isDefault: boolean;
+}
+interface Payment {
+    id: number;
+    identifier: string;
+    paymentType: {
+        id?: number;
+        code: PaymentGateway;
+    };
+    amount: number;
+}
+interface PaymentAction {
+    action: 'POST' | 'REDIRECT' | 'UPLOAD' | 'pending' | 'showOrder' | 'StockViolated' | 'FAIL';
+    address?: string;
+    payload?: JsonObject;
+    order?: Order;
+    time?: number;
+    message?: string;
+}
+interface PaymentCredentials {
+    id: number;
+    identifier: string;
+}
+interface CreatePaymentInput {
+    invoiceId: number;
+    invoiceIdentifier: string;
+    paymentType: number;
+}
+interface PaymentStepInput {
+    id?: number;
+    paymentIdentifier?: string;
+    payload?: JsonObject;
+    tatoken?: string;
+    trackingData?: JsonObject;
+    isFailed?: string;
+    imageUrl?: string;
+    code?: string;
+}
+type PaymentStepFormValue = string | number | boolean | null | undefined;
+type PaymentStepFormFields = Record<string, PaymentStepFormValue>;
+
+/**
+ * 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?: JsonObject;
+    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?: JsonObject;
+    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[];
+}
+
+/**
+ * Credentials Manager for guest users
+ * Manages cart, invoice, shipping, and payment credentials.
+ * Accepts an optional StorageAdapter — defaults to localStorage in browsers,
+ * in-memory otherwise (SSR / server actions).
+ */
+
+interface StorageAdapter {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+declare class MemoryStorage implements StorageAdapter {
+    private data;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+declare class CredentialsManager {
+    private readonly CART_KEY;
+    private readonly INVOICE_KEY;
+    private readonly SHIPPING_KEY;
+    private readonly PAYMENT_KEY;
+    private readonly DISCOUNT_KEY;
+    private storage;
+    constructor(storage?: StorageAdapter);
+    /**
+     * Cart Credentials
+     */
+    getCartCredentials(): CartCredentials | null;
+    setCartCredentials(credentials: CartCredentials & {
+        id?: number;
+    }): 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;
+    private getItem;
+    private setItem;
+    private removeItem;
+}
+
+/**
+ * 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;
+    private isMultipartBody;
+    /**
+     * 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: JsonObject;
+    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>>;
+}
+
+/**
+ * Cart API
+ * Supports both authenticated and guest users via credentials
+ */
+
+interface AddItemAttributesInput {
+    formAttributes?: Record<string, FormAttributeValue>;
+    schedulerBookingAttributes?: CreateCartInput['schedulerBookingAttributes'];
+    coupon?: string;
+}
+interface UpdateItemAttributesInput {
+    formAttributes?: Record<string, FormAttributeValue>;
+    coupon?: string;
+    deleteCoupon?: boolean;
+}
+declare class CartAPI {
+    private http;
+    private credentials;
+    constructor(http: HttpClient, credentials: CredentialsManager);
+    private persistCartCredentials;
+    /**
+     * 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, FormAttributeValue>, options?: RequestOptions): Promise<SazitoResponse<Cart>>;
+    /**
+     * Add item to cart with standardized attributes payload.
+     */
+    addItemWithAttributes(variantId: number, count: number, attributes?: AddItemAttributesInput, options?: RequestOptions): Promise<SazitoResponse<Cart>>;
+    /**
+     * Update cart item quantity
+     */
+    updateItem(cartProductId: number | string, variantId: number, count: number, formAttributes?: Record<string, FormAttributeValue>, options?: RequestOptions): Promise<SazitoResponse<Cart>>;
+    /**
+     * Update cart item quantity and optional coupon mutations.
+     */
+    updateItemWithAttributes(cartProductId: number | string, variantId: number, count: number, attributes?: UpdateItemAttributesInput, options?: RequestOptions): Promise<SazitoResponse<Cart>>;
+    /**
+     * Remove item from cart
+     */
+    removeItem(cartProductId: number | string, 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<OrdersListResponse>>;
+    /**
+     * Get single order by ID (requires authentication)
+     */
+    get(orderId: number, options?: RequestOptions): Promise<SazitoResponse<Order>>;
+}
+
+/**
+ * Invoices API (Checkout)
+ */
+
+interface AddInvoiceFormInput {
+    formAttributes: JsonObject;
+    invoiceIdentifier?: string;
+    identifier?: string;
+}
+declare class InvoicesAPI {
+    private http;
+    private credentials;
+    constructor(http: HttpClient, credentials: CredentialsManager);
+    private normalizeInvoiceResponse;
+    /**
+     * 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>>;
+    /**
+     * Attach checkout dynamic form data to invoice.
+     */
+    addForm(input: AddInvoiceFormInput, options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Apply wallet credit to invoice.
+     */
+    addCredit(options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Remove wallet credit from invoice.
+     */
+    removeCredit(options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Toggle wallet credit based on current invoice state.
+     */
+    toggleCredit(options?: RequestOptions): Promise<SazitoResponse<Invoice>>;
+    /**
+     * Get applicable shipping methods for invoice
+     */
+    getApplicableShippingMethods(options?: RequestOptions): Promise<SazitoResponse<ApplicableShippingMethods>>;
+    /**
+     * Clear current invoice credentials
+     */
+    clearInvoice(): void;
+}
+
+/**
+ * Shipping API (Addresses and Methods)
+ */
+
+declare class ShippingAPI {
+    private http;
+    private credentials;
+    constructor(http: HttpClient, credentials: CredentialsManager);
+    private sanitizeAddressInput;
+    private unwrapAddressPayload;
+    private extractAddressList;
+    /**
+     * Create shipping address
+     */
+    createAddress(address: ShippingAddressInput, options?: RequestOptions): Promise<SazitoResponse<ShippingAddress>>;
+    /**
+     * Update the address referenced by the currently stored credentials.
+     * @deprecated Do not use during checkout. Existing invoices can reference
+     * this row, so mutation can rewrite address data shown on previous orders.
+     * Create a new address snapshot with createAddress instead.
+     */
+    updateAddress(address: ShippingAddressInput, options?: RequestOptions): Promise<SazitoResponse<ShippingAddress>>;
+    /**
+     * Get the authenticated user's shipping addresses, newest first.
+     * This endpoint is intentionally not cached: checkout must see an address
+     * created by the user's most recent order immediately.
+     */
+    listAddresses(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;
+    private readonly pinchedPayments;
+    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: start the payment step before redirecting the user to
+     * the gateway. Returns the next {@link PaymentAction} (typically REDIRECT or
+     * POST for hosted gateways, or showOrder for zero-amount/instant payments).
+     */
+    initialize(options?: RequestOptions): Promise<SazitoResponse<PaymentAction>>;
+    /**
+     * Verify payment after the user returns from the gateway. Forwards the
+     * gateway callback parameters (e.g. `tatoken`, `trackingData`, `isFailed`,
+     * `code`) to the same payment-step endpoint and returns the settled
+     * {@link PaymentAction} (showOrder on success, FAIL/StockViolated otherwise,
+     * or pending if the gateway has not reported back yet).
+     */
+    verify(input?: PaymentStepInput, options?: RequestOptions): Promise<SazitoResponse<PaymentAction>>;
+    /**
+     * Process payment step (for card-to-card or multi-step payments).
+     *
+     * @deprecated Prefer {@link verify} for gateway-return verification.
+     */
+    processStep(input: PaymentStepInput, options?: RequestOptions): Promise<SazitoResponse<PaymentAction>>;
+    /**
+     * Shared core for the `process_payment_step` endpoint used by
+     * {@link initialize}, {@link verify} and {@link processStep}.
+     */
+    private submitPaymentStep;
+    /**
+     * Process payment step in form mode (non-JSON content-type).
+     */
+    processStepForm(input: FormData | PaymentStepFormFields, options?: RequestOptions): Promise<SazitoResponse<PaymentAction>>;
+    /**
+     * Poll payment state every 15 seconds until action changes from pending.
+     */
+    pollUntilSettled(options?: RequestOptions, intervalMs?: number): Promise<SazitoResponse<PaymentAction>>;
+    /**
+     * Clear payment credentials
+     */
+    clearPayment(): void;
+    private withExactJsonHeader;
+    private buildProcessStepFormData;
+    private appendFormValue;
+    /**
+     * Post-process a `process_payment_step` response. The exact-JSON endpoint
+     * returns an envelope `{ result: PaymentAction, error, error_code, status }`;
+     * unwrap `result`, surface envelope-level errors, and run the pinch hook.
+     */
+    private finalizeStepResponse;
+    private normalizeAction;
+    private callPinchAfterSuccessfulPayment;
+}
+
+/**
+ * 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);
+    private normalizeUserResponse;
+    private normalizeLoginResponse;
+    /**
+     * 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 (Tajrobe reviews + legacy feedback methods)
+ */
+
+type RecommendationStatus = 'RECOMMENDED' | 'NEUTRAL' | 'NOT-RECOMMENDED' | 'NONE';
+interface FeedbackProductAttribute {
+    name: string;
+    value: string;
+}
+interface FeedbackProductImage {
+    url: string;
+    alt: string;
+}
+interface FeedbackSeedItem {
+    productId: string;
+    productVariantId: string;
+    productName: string;
+    productAttributes: FeedbackProductAttribute[];
+    productImage: FeedbackProductImage;
+}
+interface FeedbackSeed {
+    orderId: string;
+    orderIdentifier: string;
+    hasCommentAlready: boolean;
+    items: FeedbackSeedItem[];
+}
+interface CreateOrderRatingInput {
+    orderId: string;
+    orderIdentifier: string;
+    orderRate: number;
+}
+interface CommentResponse {
+    id: string;
+}
+interface ProductReviewRequest {
+    commentId: string;
+    productId: string;
+    productVariantId: string;
+    productName: string;
+    productAttributes: FeedbackProductAttribute[];
+    productImage: FeedbackProductImage;
+    productRate: number;
+    text: string;
+    pros: string[];
+    cons: string[];
+    recommendationStatus: RecommendationStatus;
+    attachmentsServeKeys: string[];
+    owner: boolean;
+    isAnonymous: boolean;
+}
+interface ProductStatistics {
+    productStatistics: {
+        averageRate: number;
+        totalCount: number;
+        recommendations: {
+            recommendedPercentage: number;
+            recommendedTotalCount: number;
+        };
+    };
+}
+interface ProductReview {
+    productRate: number;
+    userFirstName: string;
+    userLastName: string;
+    createdAt: string;
+    owner: boolean;
+    text: string;
+    recommendationStatus: RecommendationStatus;
+    pros: string[];
+    cons: string[];
+    isAnonymous: boolean;
+    metadata: {
+        variantOptions: any[];
+        productName: string;
+        variantId: string;
+    };
+    attachments: Array<{
+        serveUrl: string;
+    }>;
+}
+interface ProductReviewsFilters {
+    pageNumber?: number;
+    pageSize?: number;
+}
+interface ProductReviewsResponse {
+    entities: ProductReview[];
+    pageNumber: number;
+    pageSize: number;
+    totalCount: number;
+    averageRate: number;
+    recommendations: {
+        recommendedPercentage: number;
+        recommendedTotalCount: number;
+    };
+}
+interface ReviewAttachmentInput {
+    file: File | Blob;
+    name?: string;
+    alt?: string;
+}
+interface ReviewUploadedImage {
+    id: string;
+    url: string;
+    alt: string;
+    serveUrl: string;
+    serveKey: string;
+}
+interface ReviewImageUploadResponse {
+    images: ReviewUploadedImage[];
+}
+/**
+ * Legacy feedback model kept for backwards compatibility.
+ */
+interface Feedback {
+    id: number;
+    user?: {
+        id: number;
+        name: string;
+    };
+    productId?: number;
+    rating?: number;
+    comment: string;
+    status: 'pending' | 'approved' | 'rejected';
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Legacy create payload kept for backwards compatibility.
+ */
+interface CreateFeedbackInput {
+    productId?: number;
+    rating?: number;
+    comment: string;
+}
+/**
+ * Legacy filters kept for backwards compatibility.
+ */
+interface FeedbackFilters {
+    productId?: number;
+    page?: number;
+    pageSize?: number;
+}
+declare class FeedbacksAPI {
+    private http;
+    constructor(http: HttpClient);
+    private normalizeSeedItem;
+    private normalizeSeed;
+    private normalizeProductReview;
+    private normalizeProductReviewsResponse;
+    private transformLegacyFilters;
+    /**
+     * Validate order and get products that can be reviewed.
+     */
+    getSeed(orderIdentifier: string, options?: RequestOptions): Promise<SazitoResponse<FeedbackSeed>>;
+    /**
+     * Submit order/shop rating and get a comment identifier for product review steps.
+     */
+    createOrderRating(input: CreateOrderRatingInput, options?: RequestOptions): Promise<SazitoResponse<CommentResponse>>;
+    /**
+     * Submit product-level review details.
+     */
+    submitProductReview(input: ProductReviewRequest, options?: RequestOptions): Promise<SazitoResponse<void>>;
+    /**
+     * Fetch product review statistics (without review list).
+     */
+    getProductStatistics(productId: string, options?: RequestOptions): Promise<SazitoResponse<ProductStatistics>>;
+    /**
+     * Fetch paginated product reviews.
+     */
+    getProductReviews(productId: string, filters?: ProductReviewsFilters, options?: RequestOptions): Promise<SazitoResponse<ProductReviewsResponse>>;
+    /**
+     * Upload review images and get serve keys for attachments.
+     */
+    uploadReviewImages(images: ReviewAttachmentInput[], options?: RequestOptions): Promise<SazitoResponse<ReviewImageUploadResponse>>;
+    /**
+     * Legacy list method kept for backwards compatibility.
+     */
+    list(filters?: FeedbackFilters, options?: RequestOptions): Promise<SazitoResponse<PaginatedResponse<Feedback>>>;
+    /**
+     * Legacy create method kept for backwards compatibility.
+     */
+    create(input: CreateFeedbackInput, options?: RequestOptions): Promise<SazitoResponse<Feedback>>;
+    /**
+     * Legacy get method kept for backwards compatibility.
+     */
+    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 (Scheduler and appointments)
+ */
+
+/**
+ * Legacy event shape returned by some scheduler list endpoints.
+ */
+interface Event {
+    id: number;
+    title: string;
+    description?: string;
+    startTime?: string;
+    endTime?: string;
+    capacity?: number;
+    bookedCount?: number;
+    availableSlots?: number;
+    price?: number;
+    location?: string;
+    createdAt?: string;
+}
+/**
+ * Event details used in product booking flow.
+ */
+interface SchedulerEvent {
+    entityId: number;
+    title: string;
+    description: string;
+    durationsMinute: number[];
+}
+interface BookingTimeSlot {
+    startTimeLocal: string;
+    endTimeLocal: string;
+    isAvailable: boolean;
+    remainingCapacity: number;
+}
+interface BookingAvailableDay {
+    date: string;
+    timeSlots: BookingTimeSlot[];
+}
+interface EventAvailabilitiesResponse {
+    availableDays: BookingAvailableDay[];
+}
+interface EventAvailabilityFilters {
+    eventEntityId: number;
+    duration: number;
+    fromDate: string;
+    toDate: string;
+    timezone?: string;
+}
+interface CreateBookingInput {
+    eventEntityId?: number;
+    event_entity_id?: number;
+    timezone: string;
+    attendeeName?: string;
+    attendee_name?: string;
+    attendeeEmail?: string;
+    attendee_email?: string;
+    attendeePhone?: string;
+    attendee_phone?: string;
+}
+interface Booking {
+    id: number;
+    eventId: number;
+    event: Event;
+    userId?: number;
+    attendeeName: string;
+    attendeeEmail?: string;
+    attendeePhone?: string;
+    status: 'pending' | 'confirmed' | 'cancelled';
+    bookingTime: string;
+    createdAt: string;
+}
+interface EventFilters {
+    startDate?: string;
+    start_date?: string;
+    endDate?: string;
+    end_date?: string;
+    availableOnly?: boolean;
+    available_only?: boolean;
+    page?: number;
+    pageSize?: number;
+    page_size?: number;
+}
+declare class BookingAPI {
+    private http;
+    constructor(http: HttpClient);
+    private transformEventFilters;
+    /**
+     * List available events (legacy scheduler listing).
+     */
+    listEvents(filters?: EventFilters, options?: RequestOptions): Promise<SazitoResponse<PaginatedResponse<Event>>>;
+    /**
+     * Get event details used for booking (durations, title, description).
+     */
+    getEvent(entityId: number, options?: RequestOptions): Promise<SazitoResponse<SchedulerEvent>>;
+    /**
+     * Get available days and time slots for an event.
+     */
+    getEventAvailabilities(filters: EventAvailabilityFilters, options?: RequestOptions): Promise<SazitoResponse<EventAvailabilitiesResponse>>;
+    /**
+     * Create booking (legacy endpoint kept for backward compatibility).
+     */
+    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;
+    private firstNonEmpty;
+    /**
+     * 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>>;
+}
+
+/**
+ * Dynamic Forms API
+ */
+
+type DynamicFormFieldType = 'TextBox' | 'TextArea' | 'Select' | 'Checkbox' | 'StatusBox' | 'Number' | 'Password' | 'NationalId' | 'PhoneNumber' | 'IBAN' | 'Separator' | 'Uploader';
+interface SelectOption {
+    value: string;
+    label: string;
+}
+interface DynamicFormField {
+    key: string;
+    name: string;
+    type: DynamicFormFieldType;
+    label: string;
+    value: any;
+    placeholder: string;
+    required: boolean;
+    inputOptions: SelectOption[];
+    allowedExtensions: string[];
+}
+interface DynamicForm {
+    id: number;
+    title: string;
+    description: string;
+    fields: DynamicFormField[];
+}
+interface UploadedDynamicFormFile {
+    serveKey: string;
+}
+declare class DynamicFormsAPI {
+    private http;
+    constructor(http: HttpClient);
+    private normalizeField;
+    private normalizeForm;
+    /**
+     * Fetch dynamic form definition by ID.
+     */
+    getForm(formId: number, options?: RequestOptions): Promise<SazitoResponse<DynamicForm>>;
+    /**
+     * Upload file for uploader fields in product dynamic forms.
+     */
+    uploadProductFormFile(file: File | Blob, options?: RequestOptions): Promise<SazitoResponse<UploadedDynamicFormFile>>;
+}
+
+/**
+ * Regions API
+ */
+
+interface RegionCity {
+    id: number;
+    name: string;
+    latitude: number;
+    longitude: number;
+}
+interface RegionWithCities {
+    id: number;
+    name: string;
+    cities: RegionCity[];
+}
+declare class RegionsAPI {
+    private http;
+    constructor(http: HttpClient);
+    private normalizeCity;
+    private normalizeRegion;
+    private extractRegions;
+    private sortAlphabetically;
+    /**
+     * Get all regions with nested cities (sorted by name).
+     */
+    list(options?: RequestOptions): Promise<SazitoResponse<RegionWithCities[]>>;
+}
+
+/**
+ * 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;
+    readonly dynamicForms: DynamicFormsAPI;
+    readonly regions: RegionsAPI;
+    constructor(config: SazitoConfig, credentialsManager?: CredentialsManager);
+    /**
+     * 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;
+    /**
+     * Access the guest credential store used by checkout-related modules.
+     * Useful for integrations that receive an SDK client from the host app and
+     * need to restore cart/invoice/payment credentials on that same instance.
+     */
+    getCredentialsManager(): CredentialsManager;
+    /**
+     * 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, credentialsManager?: CredentialsManager): 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;
+
+declare function createDynamicFormsAPI(configOrContext: SazitoConfig | ModuleContext): DynamicFormsAPI;
+
+declare function createRegionsAPI(configOrContext: SazitoConfig | ModuleContext): RegionsAPI;
+
+type TransformScalar = string | number | boolean | null | undefined;
+type TransformValue = TransformScalar | TransformObject | TransformValue[] | object;
+interface TransformObject {
+    [key: string]: TransformValue;
+}
+interface ApiResponseEnvelope {
+    data?: {
+        result?: TransformObject;
+    };
+}
+/** Convert Persian and Arabic-Indic numerals to ASCII digits. */
+declare function toEnglishDigits(input: string): string;
+/**
+ * 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: TransformValue | object): TransformValue;
+/**
+ * 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: TransformValue | object): TransformValue;
+/**
+ * Transform API response data structure
+ * Unwraps the { data: { result: { ... } } } structure and transforms keys
+ */
+declare function transformApiResponse<T = TransformObject>(response: TransformValue | ApiResponseEnvelope | object): T;
+/**
+ * Specific transformer for cart responses
+ * Handles the cart-specific data structure
+ */
+declare function transformCartResponse<T = TransformObject>(response: TransformValue | ApiResponseEnvelope | object): T;
+declare function transformInvoiceResponse<T = TransformObject>(response: TransformValue | ApiResponseEnvelope | object): T;
+/**
+ * Specific transformer for product list responses
+ * Handles paginated product lists
+ */
+declare function transformProductListResponse<T = TransformObject>(response: TransformValue | ApiResponseEnvelope | object): T;
+/**
+ * Transform shipping address input for API request
+ */
+declare function transformShippingAddressInput(input: TransformValue): TransformObject;
+/**
+ * Transform add to cart input for API request
+ */
+declare function transformAddToCartInput(variantId: number, quantity: number, formAttributes?: TransformValue): TransformObject;
+/**
+ * Transform create cart input for API request
+ */
+declare function transformCreateCartInput(input: TransformValue): TransformObject;
+
+export { CredentialsManager, HttpClient, MemoryStorage, SazitoClient, TokenStorage, createBookingAPI as booking, createCartAPI as cart, createCategoriesAPI as categories, createCMSAPI as cms, createBookingAPI, createCMSAPI, createCartAPI, createCategoriesAPI, createDynamicFormsAPI, createEntityRoutesAPI, createFeedbacksAPI, createGeneralAPI, createImagesAPI, createInvoicesAPI, createMenuAPI, createOrdersAPI, createPaymentsAPI, createProductsAPI, createRegionsAPI, createSazitoClient, createSearchAPI, createShippingAPI, createUsersAPI, createVisitsAPI, createWalletAPI, createDynamicFormsAPI as dynamicForms, 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, createRegionsAPI as regions, createSearchAPI as search, createShippingAPI as shipping, toEnglishDigits, transformAddToCartInput, transformApiResponse, transformCartResponse, transformCreateCartInput, transformInvoiceResponse, transformProductListResponse, transformRequestKeys, transformResponseKeys, transformShippingAddressInput, createUsersAPI as users, createVisitsAPI as visits, createWalletAPI as wallet };
+export type { AddToCartInput, ApplicableShippingMethods, BlogPage, BlogPageEntityRoute, CMSPageEntityRoute, CMSPageType, CacheConfig, Cart, CartCredentials, CartProduct, CheckoutProductSnapshot, City$1 as City, CmsPage, CookieOptions, CreateCartInput, CreateInvoiceInput, CreatePaymentInput, EntityRoute, EntityRouteResponse, EntityType, FormAttributeValue, Image, Invoice, InvoiceCredentials, InvoiceItem, InvoiceItemFormAttributes, InvoiceShippingAddress, InvoiceShippingAddressRegion, ItemShippingRate, JsonArray, JsonObject, JsonPrimitive, JsonValue, MenuItem, MenuNode, MenuTree, Order, OrderFilters, OrdersListResponse, PaginatedResponse, Payment, PaymentAction, PaymentCredentials, PaymentGateway, PaymentMethod, PaymentStatus, PaymentStepFormFields, PaymentStepFormValue, PaymentStepInput, Product, ProductAttribute, ProductAttributeValueObject, ProductCategory, ProductCategoryEntityRoute, ProductEntityRoute, ProductFilters, ProductSort, ProductVariant, RefreshInvoiceInput, Region$1 as Region, RequestOptions, RetryConfig, SazitoConfig, SazitoResponse, SchedulerBookingAttributes, SearchFilters, SearchResponse, ShippingAddress, ShippingAddressCity, ShippingAddressCredentials, ShippingAddressInput, ShippingAddressRegion, ShippingAssignment, ShippingItem, ShippingMethod, ShippingRate, StorageAdapter, Tag, UnknownEntityRoute, UploadedFormFileAttribute, User };