@altazion/commerce-sdk-core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,998 @@
+/**
+ * Erreur générée par l'API Altazion Commerce (HTTP 4xx / 5xx).
+ */
+export declare class AltazionApiError extends Error {
+    readonly status: number;
+    readonly problem: ProblemDetails;
+    constructor(status: number, problem: ProblemDetails);
+}
+
+/** Produit associé avec ses détails — même structure que WebProduct */
+export declare type AssociatedProductWithDetails = WebProduct;
+
+/** Niveau de disponibilité : 0=Disponible, 1=Limité, 2=Indisponible */
+export declare type AvailabilityLevel = 0 | 1 | 2;
+
+/** Source de la disponibilité */
+export declare type AvailabilitySource = 'DB' | 'DO' | 'US';
+
+/**
+ * Erreur liée à une opération sur le cache (IndexedDB, SharedWorker).
+ */
+export declare class CacheError extends Error {
+    readonly cause: unknown;
+    constructor(message: string, cause?: unknown);
+}
+
+declare class CacheStrategy {
+    private readonly bridge;
+    private readonly http;
+    constructor(bridge: WorkerBridge, http: CommerceHttpAdapter);
+    /**
+     * Exécute la requête selon la stratégie choisie.
+     *
+     * @param key        Clé de cache (généralement le path + params)
+     * @param fetcher    Fonction qui effectue la requête HTTP
+     * @param strategy   Stratégie à appliquer
+     * @param ttlMs      TTL du cache (override la valeur par défaut)
+     */
+    execute<T>(key: string, fetcher: () => Promise<T>, strategy: CacheStrategyName, ttlMs?: number): Promise<T>;
+    private networkFirst;
+    private cacheFirst;
+    private staleWhileRevalidate;
+}
+
+/**
+ * Stratégies de cache disponibles pour les requêtes HTTP.
+ */
+export declare type CacheStrategyName = 'network-only' | 'network-first' | 'cache-first' | 'stale-while-revalidate';
+
+export declare interface Cart {
+    guid: string;
+    orderNumber?: string | null;
+    expectedDestinationPostalCode?: string | null;
+    expectedDestinationCountryCode?: string | null;
+    state: CartStatus;
+    customerGuid?: string | null;
+    billingAddress: CustomerAddress;
+    shippingAddresses?: CustomerAddress[] | null;
+    pickupPointAddresses?: PickupPointAddressDetails[] | null;
+    customerName?: string | null;
+    isCustomerLoggedIn: boolean;
+    content?: CartContent[] | null;
+    activeBenefitCode?: string | null;
+    totalAmountWithTax: number;
+    totalAmountWithoutTax: number;
+    totalQuantity: number;
+    createdDate: string;
+    lastModifiedDate: string;
+    associatedDeviceGuid?: string | null;
+    tags?: string[] | null;
+    payments?: CartPayment[] | null;
+    pickupPersonName?: string | null;
+}
+
+export declare interface CartBenefit {
+    offerGuid?: string | null;
+    couponGuid?: string | null;
+}
+
+export declare interface CartBundleComposition {
+    label?: string | null;
+    price: number;
+    image?: string | null;
+    parentGuid: string;
+    productGuids?: string[] | null;
+}
+
+/** Groupe de lignes du panier (par mode de livraison / prestataire) */
+export declare interface CartContent {
+    lines?: CartLine[] | null;
+    contentType: CartContentType;
+    /** Ligne de frais de livraison associée */
+    shippingFees: CartLine;
+    benefitsLines?: CartLine[] | null;
+    associatedBenefits?: CartBenefit[] | null;
+    isValidatable: boolean;
+    requiresShippingFees: boolean;
+    cartErrors?: CartError[] | null;
+    incentiveMessage?: string | null;
+    deliveryModeGuid?: string | null;
+    deliveryModeIsPickupPoint?: boolean | null;
+    shippingAddressGuid: string;
+    pickupPointAddressGuid?: string | null;
+    totalAmountWithTax: number;
+    totalAmountWithTaxFormatted?: string | null;
+    preferredProcess?: string | null;
+    groupInfo: CartGroup;
+    totalPromotionDiscount: number;
+}
+
+/** Type de contenu d'un groupe de lignes du panier */
+export declare type CartContentType = 'MainLines' | 'ShipFromStoreLines' | 'StorePickupLines' | 'VendorLines' | 'DropShipLines';
+
+export declare interface CartError {
+    errorCode: number;
+    severity: CartErrorSeverity;
+    message?: string | null;
+    isBlocking: boolean;
+    correctionMessage?: string | null;
+    correctionUrl?: string | null;
+    isAutomaticRedirection: boolean;
+}
+
+/** Sévérité d'erreur : 0=Info, 1=Erreur */
+export declare type CartErrorSeverity = 0 | 1;
+
+export declare interface CartGroup {
+    code?: string | null;
+    label?: string | null;
+    details?: string | null;
+    associatedProcessType?: string | null;
+    isExternal: boolean;
+}
+
+export declare interface CartLine {
+    itemType: ProductMetaType;
+    id: string;
+    parentLineId?: string | null;
+    label?: string | null;
+    reference?: string | null;
+    productGuid: string;
+    quantity: number;
+    originalNonDiscountedUnitPriceExclTax: number;
+    originalNonDiscountedUnitPriceInclTax: number;
+    originalUnitPriceExclTax: number;
+    originalUnitPriceInclTax: number;
+    finalUnitPriceInclTax: number;
+    finalUnitPriceExclTax: number;
+    unitDiscountExclTax: number;
+    unitDiscountInclTax: number;
+    imageUrl?: string | null;
+    intermediateImageUrl?: string | null;
+    isUpdated: boolean;
+    brand?: string | null;
+    storeGuid?: string | null;
+    isNotEditable: boolean;
+    distinguishingAttributes?: string[] | null;
+    customData?: string[] | null;
+    ancillaryFeesDetails?: string[] | null;
+    isAvailableInStore?: boolean | null;
+    quantityAvailableInStore?: number | null;
+    isAvailableInCentral?: boolean | null;
+    quantityAvailableInCentral?: number | null;
+    associatedItemBundles?: CartBundleComposition[] | null;
+    fullfilmentInfo: FullfilmentCartInfo;
+    appliedDiscounts?: CartLineDiscount[] | null;
+    dimensions: ProductDimensionsBase;
+}
+
+export declare interface CartLineDiscount {
+    offerGuid?: string | null;
+    offerCode?: string | null;
+    quantityOffered?: number | null;
+    unitDiscountExclTax: number;
+    unitDiscountInclTax: number;
+}
+
+declare class CartModule {
+    private readonly http;
+    private readonly cache;
+    private readonly queue;
+    private readonly connectivity;
+    constructor(http: CommerceHttpAdapter, cache: CacheStrategy, queue: OfflineQueue, connectivity: ConnectivityManager);
+    /** Récupère le panier en cours */
+    getCart(): Promise<Cart>;
+    /** Récupère le statut de validation du panier */
+    getValidationStatus(): Promise<CartValidationStatus>;
+    /** Ajoute un article au panier */
+    addItem(reference: string, quantity: number, options?: Record<string, unknown>): Promise<Cart>;
+    /** Met à jour la quantité d'une ligne */
+    updateItem(lineId: string, quantity: number): Promise<Cart>;
+    /** Supprime une ligne du panier */
+    removeItem(lineId: string): Promise<Cart>;
+    /** Applique un coupon */
+    applyCoupon(code: string): Promise<Cart>;
+    /** Retire un coupon */
+    removeCoupon(code: string): Promise<Cart>;
+}
+
+export declare interface CartPayment {
+    paymentGuid: string;
+    amount: number;
+    paymentMethodGuid: string;
+    isCompleted: boolean;
+    pspReference?: string | null;
+}
+
+/** État du panier : 0=Actif, 1=Complété, 2=En préparation, 127=Verrouillé */
+export declare type CartStatus = 0 | 1 | 2 | 127;
+
+export declare interface CartValidationStatus {
+    canBeOrdered: boolean;
+    canBeCompleted: boolean;
+    unavailableProducts?: InvalidProduct[] | null;
+    validationErrors?: CartError[] | null;
+}
+
+declare class CatalogModule {
+    private readonly http;
+    private readonly cache;
+    constructor(http: CommerceHttpAdapter, cache: CacheStrategy);
+    /** Récupère le détail d'un produit par sa référence */
+    getProduct(reference: string): Promise<ProductDetails>;
+    /** Récupère une liste de produits par leurs références */
+    getProducts(references: string[]): Promise<WebProduct[]>;
+    /** Récupère les produits d'une catégorie */
+    getCategory(categoryCode: string, pageIndex?: number, pageSize?: number): Promise<SearchResult>;
+    /** Effectue une recherche full-text */
+    search(request: SearchRequest): Promise<SearchResult>;
+    /** Récupère les suggestions de recherche (autocomplete) */
+    suggest(query: string): Promise<string[]>;
+}
+
+/**
+ * Point d'entrée principal du SDK Altazion Commerce.
+ *
+ * Usage :
+ * ```ts
+ * const client = new CommerceClient({ baseUrl: 'https://api.monsite.com', siteUrl: window.location.href })
+ * await client.initialize()
+ *
+ * const cart = await client.cart.getCart()
+ * ```
+ */
+export declare class CommerceClient {
+    readonly context: CommerceContext;
+    readonly connectivity: ConnectivityManager;
+    readonly session: SessionModule;
+    readonly cart: CartModule;
+    readonly catalog: CatalogModule;
+    readonly shipping: ShippingModule;
+    readonly marketing: MarketingModule;
+    readonly stores: StoresModule;
+    private readonly http;
+    private readonly workerBridge;
+    private readonly cacheStrategy;
+    private readonly offlineQueue;
+    private readonly sessionManager;
+    private unsubscribeOnline;
+    constructor(options: CommerceContextOptions);
+    /**
+     * Initialise le SDK :
+     * - Crée la session si nécessaire (mode browser uniquement)
+     * - Abonne le flush automatique de la file hors-ligne au retour en ligne
+     */
+    initialize(): Promise<SessionInfo | null>;
+    /**
+     * Retourne vrai si le SDK est hors-ligne.
+     */
+    get isOffline(): boolean;
+    /**
+     * Retourne le nombre d'opérations en attente dans la file hors-ligne.
+     */
+    get pendingOperationsCount(): Promise<number>;
+    /**
+     * Abonne un listener aux événements de la file hors-ligne.
+     * Retourne une fonction de désabonnement.
+     */
+    onQueueEvent(listener: Parameters<OfflineQueue['subscribe']>[0]): () => void;
+    /**
+     * Force le vidage du cache.
+     */
+    clearCache(): Promise<void>;
+    /**
+     * Libère les ressources (listeners, worker).
+     */
+    dispose(): void;
+}
+
+/**
+ * Contexte partagé du SDK, instancié une seule fois et transmis
+ * à tous les sous-systèmes (HttpAdapter, SessionManager, modules…).
+ */
+export declare class CommerceContext {
+    readonly baseUrl: string;
+    readonly siteUrl: string | undefined;
+    readonly sitePk: number | undefined;
+    readonly rjsId: number | undefined;
+    readonly locale: string;
+    readonly currency: string;
+    readonly mode: CommerceMode;
+    constructor(options: CommerceContextOptions);
+    private static detectMode;
+}
+
+export declare interface CommerceContextOptions {
+    /** URL de base de l'API (ex. : "https://api.monsite.com") */
+    baseUrl: string;
+    /** Identifiant ou URL du site web pour la création de session (mode browser) */
+    siteUrl?: string;
+    /**
+     * Clé primaire du site (alternative à siteUrl).
+     * Requiert aussi rjsId.
+     */
+    sitePk?: number;
+    /** Identifiant du tenant RJS (nécessaire avec sitePk) */
+    rjsId?: number;
+    /** Locale par défaut (ex. : "fr-FR") */
+    locale?: string;
+    /** Devise par défaut (ex. : "EUR") */
+    currency?: string;
+}
+
+/**
+ * Adaptateur HTTP basé sur fetch natif.
+ *
+ * Responsabilités :
+ * - Construction des URLs à partir du baseUrl du contexte
+ * - Ajout des headers standard (Content-Type, Accept, locale)
+ * - credentials: 'include' pour la transmission automatique des cookies (modes browser et kiosk)
+ * - Parse des réponses ProblemDetails en AltazionApiError
+ * - Retry limité sur les erreurs réseau (TypeError), jamais sur les 4xx/5xx
+ */
+declare class CommerceHttpAdapter {
+    private readonly context;
+    constructor(context: CommerceContext);
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    private handleResponse;
+    /** Effectue un GET et retourne T */
+    get<T>(path: string, headers?: Record<string, string>): Promise<T>;
+    /** Effectue un POST avec un body JSON et retourne T */
+    post<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    /** Effectue un PUT avec un body JSON et retourne T */
+    put<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    /** Effectue un PATCH avec un body JSON et retourne T */
+    patch<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    /** Effectue un DELETE et retourne T */
+    delete<T>(path: string, headers?: Record<string, string>): Promise<T>;
+}
+
+/**
+ * Mode d'exécution du SDK.
+ * - `browser` : navigateur classique — le SDK gère la création de session et le cookie.
+ * - `kiosk`   : borne avec "Altazion Device Shell" — le browser embarqué gère les cookies.
+ */
+export declare type CommerceMode = 'browser' | 'kiosk';
+
+export declare type ConnectivityListener = (status: ConnectivityStatus) => void;
+
+/**
+ * Surveille l'état de la connexion réseau.
+ *
+ * - Utilise navigator.onLine comme valeur initiale
+ * - Écoute les événements window 'online' / 'offline'
+ * - Permet d'abonner des listeners (pattern observable léger)
+ */
+export declare class ConnectivityManager {
+    private status;
+    private readonly listeners;
+    constructor();
+    get isOnline(): boolean;
+    get isOffline(): boolean;
+    /**
+     * Abonne un listener aux changements de connectivité.
+     * Retourne une fonction de désabonnement.
+     */
+    subscribe(listener: ConnectivityListener): () => void;
+    /** Libère les event listeners sur window. */
+    dispose(): void;
+    private readOnlineStatus;
+    private readonly handleOnline;
+    private readonly handleOffline;
+    private emit;
+}
+
+export declare type ConnectivityStatus = 'online' | 'offline';
+
+/** Adresse client stockée (table gestcom_clients_adresses) */
+export declare interface CustomerAddress {
+    addressGuid: string;
+    customerGuid: string;
+    isActive: boolean;
+    title?: string | null;
+    company?: string | null;
+    fullName?: string | null;
+    streetAddress?: string | null;
+    postalCode?: string | null;
+    city?: string | null;
+    countryCode?: string | null;
+    phone?: string | null;
+    email?: string | null;
+    isBillingAddress: boolean;
+    siteId: number;
+    isDefault: boolean;
+    region?: string | null;
+    isTemporary: boolean;
+    mobile?: string | null;
+}
+
+/** Jour de la semaine (convention .NET) : 0=Dimanche … 6=Samedi */
+export declare type DayOfWeek = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+/** Type de service de livraison : 0=Standard, 1=Express, 2=SameDayDelivery */
+export declare type DeliveryServiceType = 0 | 1 | 2;
+
+export declare interface FullfilmentCartInfo {
+    fullfilmentKind?: string | null;
+    fullfilmentCode?: string | null;
+    fullfilmentPartnerId?: string | null;
+    fullfilmentPartnerName?: string | null;
+}
+
+/** Produit indisponible dans le panier */
+export declare interface InvalidProduct extends WebProduct {
+    availableSubstitutions?: WebProduct[] | null;
+}
+
+export declare interface MarketingItem {
+    linkItem?: MarketingLinkItem;
+    xmlData?: unknown;
+    htmlData?: unknown;
+}
+
+export declare interface MarketingLinkItem {
+    guid: string;
+    stepGuid: string;
+    mimeType?: string | null;
+    imageUrl?: string | null;
+    targetSelectionGuid?: string | null;
+    targetUrl?: string | null;
+    keyword?: string | null;
+    width?: number | null;
+    height?: number | null;
+    altData?: string | null;
+    htmlContent?: string | null;
+    kind?: string | null;
+}
+
+declare class MarketingModule {
+    private readonly http;
+    private readonly cache;
+    constructor(http: CommerceHttpAdapter, cache: CacheStrategy);
+    /** Récupère un item marketing par son code */
+    getItem(code: string): Promise<MarketingItem>;
+    /** Récupère plusieurs items marketing par leurs codes */
+    getItems(codes: string[]): Promise<MarketingItem[]>;
+}
+
+/**
+ * Erreur levée lorsque le SDK est hors-ligne et ne peut pas
+ * satisfaire la requête depuis le cache.
+ */
+export declare class OfflineError extends Error {
+    constructor(message?: string);
+}
+
+/**
+ * File d'attente persistante (IndexedDB) pour les mutations effectuées hors-ligne.
+ *
+ * Flux :
+ * 1. `enqueue(operation)` — stocke l'opération en IndexedDB
+ * 2. Au retour en ligne, `flush()` rejoue les opérations dans l'ordre d'enfilage
+ * 3. En cas d'erreur 4xx (conflit) : émet un événement `conflict` et ne retire PAS l'opération
+ * 4. En cas de succès : retire l'opération de la file
+ */
+declare class OfflineQueue {
+    private db;
+    private readonly listeners;
+    private counter;
+    /** Abonne un listener aux événements de file. Retourne une fonction de désabonnement. */
+    subscribe(listener: QueueEventListener): () => void;
+    get pendingCount(): Promise<number>;
+    enqueue(method: QueuedOperation['method'], path: string, body?: unknown, headers?: Record<string, string>): Promise<QueuedOperation>;
+    /**
+     * Rejoue toutes les opérations en attente dans l'ordre d'enfilage.
+     * S'arrête sur un conflit (4xx) et émet un événement `conflict`.
+     */
+    flush(http: CommerceHttpAdapter): Promise<void>;
+    private emit;
+    private openDb;
+    private put;
+    private remove;
+    private getAll;
+}
+
+/** Point de livraison (point relais, locker, consigne) */
+export declare interface PickupPoint {
+    id: string;
+    carrierId: number;
+    name?: string | null;
+    address?: string | null;
+    postalCode?: string | null;
+    city?: string | null;
+    countryCode?: string | null;
+    platformLevel1?: string | null;
+    platformLevel2?: string | null;
+    platformLevel3?: string | null;
+    platformLevel4?: string | null;
+    platformLevel5?: string | null;
+    isPrimary: boolean;
+    externalCode?: string | null;
+    startDate: string;
+    endDate: string;
+    accessIndications?: string | null;
+    availableServices?: string | null;
+    longitude?: number | null;
+    latitude?: number | null;
+    phoneNumber?: string | null;
+    isActive: boolean;
+}
+
+/** Point de livraison avec ses horaires d'ouverture */
+export declare interface PickupPointAddressDetails extends PickupPoint {
+    horaires?: unknown[] | null;
+    moreInfo?: string | null;
+}
+
+/**
+ * Représentation d'une réponse d'erreur ProblemDetails (RFC 9457)
+ * telle que renvoyée par GlobalExceptionFilter.cs
+ */
+export declare interface ProblemDetails {
+    type?: string;
+    title?: string;
+    status?: number;
+    detail?: string;
+    instance?: string;
+    [key: string]: unknown;
+}
+
+export declare interface ProductAvailabilitySummary {
+    notAvailableUntil?: string | null;
+    notAvailableAfter?: string | null;
+    statusCode?: string | null;
+    status: AvailabilityLevel;
+    web: ProductWebAvailability;
+    local: ProductStoreAvailability;
+    stores?: Record<string, ProductStoreAvailability> | null;
+    source: AvailabilitySource;
+}
+
+export declare interface ProductCustomAttributeWithDefinition {
+    enumeratedValue?: number | null;
+    attributeGuid: string;
+    decimalValue?: number | null;
+    booleanValue?: boolean | null;
+    textValue?: string | null;
+    dateValue?: string | null;
+    attributeLabel?: string | null;
+    isPublic: boolean;
+}
+
+export declare interface ProductDetails extends WebProduct {
+    dimensions: ProductDimensionsBase;
+    taxes: ProductTaxBase[];
+    parent: WebProduct;
+    availability: ProductAvailabilitySummary;
+    instances: ProductInstance[];
+    documents: string[];
+    videos: string[];
+    moreImages: ProductImage[];
+    labels: string[];
+    customAttributes: ProductCustomAttributeWithDefinition[];
+    logosUrls: string[];
+    associatedProducts: Record<string, AssociatedProductWithDetails[]>;
+    suggestionsAuto: WebProduct[];
+    reviews: ProductReview[];
+    url: string;
+    fulfillmentConditions: ProductLogisticsInfoBase;
+}
+
+export declare interface ProductDimensionsBase {
+    netHeight?: number | null;
+    netWidth?: number | null;
+    netLength?: number | null;
+    netWeight?: number | null;
+    netVolume?: number | null;
+    grossHeight: number;
+    grossWidth: number;
+    grossLength: number;
+    grossWeight: number;
+    grossVolume: number;
+}
+
+export declare interface ProductImage {
+    urlSmall?: string | null;
+    urlBig?: string | null;
+}
+
+/** Instance de produit (variation) — même structure que WebProduct */
+export declare type ProductInstance = WebProduct;
+
+declare interface ProductLogisticsInfoBase {
+    fulfillmentTypeCode?: string | null;
+    fulFillmentMandatoryZoneGuid?: string | null;
+    isHighDemand: boolean;
+}
+
+/** Type de méta-produit (0-8) */
+export declare type ProductMetaType = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+export declare interface ProductReview {
+    guid: string;
+    productGuid: string;
+    reviewerName?: string | null;
+    message?: string | null;
+    customerGuid?: string | null;
+    email?: string | null;
+    hasBeenValidated: boolean;
+    date: string;
+    note: number;
+}
+
+export declare interface ProductStoreAvailability {
+    isAvailable: boolean;
+    quantity?: number | null;
+    distance?: number | null;
+    source: AvailabilitySource;
+}
+
+declare interface ProductTaxBase {
+    guid: string;
+    taxeDefinitionGuid: string;
+    amount: number;
+}
+
+export declare interface ProductWebAvailability {
+    isAvailable: boolean;
+    isAvailableFromWarehouse: boolean;
+    isAvailableFromOther: boolean;
+    warehouseQuantity?: number | null;
+    otherQuantity?: number | null;
+    source: AvailabilitySource;
+}
+
+/**
+ * Représente une opération en attente dans la file hors-ligne.
+ */
+export declare interface QueuedOperation {
+    /** Identifiant unique de l'opération */
+    id: string;
+    /** Timestamp d'enfilage */
+    enqueuedAt: number;
+    /** Méthode HTTP */
+    method: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /** Path de la requête (sans baseUrl) */
+    path: string;
+    /** Corps de la requête sérialisé */
+    body: unknown;
+    /** Headers supplémentaires */
+    headers?: Record<string, string>;
+    /** Nombre de tentatives déjà effectuées */
+    attempts: number;
+}
+
+export declare interface QueueEvent {
+    type: QueueEventType;
+    operation?: QueuedOperation;
+    error?: QueueFlushError;
+}
+
+export declare type QueueEventListener = (event: QueueEvent) => void;
+
+export declare type QueueEventType = 'enqueued' | 'flushed' | 'conflict' | 'emptied';
+
+/**
+ * Erreur levée lors du rejeu de l'OfflineQueue (conflit serveur).
+ */
+export declare class QueueFlushError extends Error {
+    readonly failedOperationId: string;
+    readonly apiError: AltazionApiError;
+    constructor(operationId: string, apiError: AltazionApiError);
+}
+
+declare interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    body?: unknown;
+    headers?: Record<string, string>;
+    /** Nombre maximum de tentatives réseau (uniquement sur erreurs réseau, jamais sur 4xx) */
+    maxRetries?: number;
+}
+
+export declare interface SearchFacet {
+    /** Nom de la facette */
+    n?: string | null;
+    /** Valeurs de la facette */
+    i?: SearchFacetValue[] | null;
+}
+
+export declare interface SearchFacetValue {
+    /** Valeur */
+    v?: string | null;
+    /** Libellé */
+    n?: string | null;
+    /** Nombre de résultats */
+    c: number;
+}
+
+export declare interface SearchRequest {
+    /** Terme de recherche */
+    q?: string | null;
+    /** Index de départ (pagination) */
+    offset: number;
+    /** Nombre de résultats demandés */
+    length: number;
+    /** Filtres sous forme de chaîne (format interne) */
+    filters?: string | null;
+}
+
+export declare interface SearchResult {
+    totalCount: number;
+    offset: number;
+    length: number;
+    elements?: SearchResultElement[] | null;
+    facets?: SearchFacet[] | null;
+}
+
+export declare interface SearchResultElement {
+    /** Produit */
+    p: WebProduct;
+    /** Score de pertinence */
+    s?: number | null;
+}
+
+export declare interface SessionInfo {
+    id: string;
+    expiresOn?: string | null;
+    loggedUserGuid?: string | null;
+    loggedUserEmail?: string | null;
+    associatedStoreGuid?: string | null;
+    associatedDeviceGuid?: string | null;
+    hasCart: boolean;
+    cartId?: string | null;
+    rjsId: number;
+    sitePk: number;
+    marketingTestDate?: string | null;
+}
+
+/**
+ * Interface commune pour la gestion de session.
+ * Deux implémentations : BrowserSessionManager (mode browser) et KioskSessionManager (mode borne).
+ */
+export declare interface SessionManager {
+    /**
+     * Initialise la session.
+     * En mode browser : crée une session si elle n'existe pas encore.
+     * En mode kiosk : no-op.
+     */
+    initialize(): Promise<SessionInfo | null>;
+    /**
+     * Signale que la session a expiré.
+     * En mode browser : peut tenter de recréer une session.
+     * En mode kiosk : no-op.
+     */
+    onSessionExpired(): Promise<void>;
+}
+
+declare class SessionModule {
+    private readonly http;
+    private readonly cache;
+    constructor(http: CommerceHttpAdapter, cache: CacheStrategy);
+    /** Récupère les informations de la session en cours */
+    getSession(): Promise<SessionInfo>;
+    /** Associe un magasin à la session */
+    associateStore(storeGuid: string): Promise<SessionInfo>;
+}
+
+/** Adresse de livraison pour le checkout */
+export declare interface ShippingAddress {
+    guid: string;
+    title?: string | null;
+    name?: string | null;
+    streetAddress?: string | null;
+    city?: string | null;
+    phone?: string | null;
+    mobile?: string | null;
+    postalCode?: string | null;
+    email?: string | null;
+    isForInvoice: boolean;
+}
+
+export declare interface ShippingChoice {
+    id?: string | null;
+    isPickupPoint: boolean;
+    carrierLabel?: string | null;
+    reference?: string | null;
+    priceExclTax: number;
+    priceInclTax: number;
+    originalPriceExclTax: number;
+    originalPriceInclTax: number;
+    discountExclTax: number;
+    discountInclTax: number;
+    formattedPrice?: string | null;
+    formattedOriginalPrice?: string | null;
+    formattedDiscount?: string | null;
+    estimatedDeliveryDate: string;
+    formattedEstimatedDeliveryDate?: string | null;
+    destinationType: ShippingDestinationKind;
+    serviceType: DeliveryServiceType;
+    isActive: boolean;
+    shippingProviderId: number;
+    priority: number;
+    publicLabel?: string | null;
+}
+
+export declare interface ShippingChoiceGroup {
+    groupName?: string | null;
+    minPrice?: number | null;
+    maxPrice?: number | null;
+    earliestDeliveryDate?: string | null;
+    choices?: ShippingChoice[] | null;
+    groupDestination: ShippingDestinationKind;
+    groupServiceType: DeliveryServiceType;
+    applicableCartContentTypes?: string[] | null;
+}
+
+/** Type de destination de livraison : 0=Adresse, 1=Magasin, 2=PointRelais */
+export declare type ShippingDestinationKind = 0 | 1 | 2;
+
+declare class ShippingModule {
+    private readonly http;
+    private readonly cache;
+    constructor(http: CommerceHttpAdapter, cache: CacheStrategy);
+    /** Récupère les groupes de modes de livraison disponibles pour le panier en cours */
+    getAvailableModes(): Promise<ShippingChoiceGroup[]>;
+    /** Sélectionne un mode de livraison */
+    selectMode(shippingModeGuid: string): Promise<void>;
+    /** Met à jour l'adresse de livraison */
+    setAddress(address: ShippingAddress): Promise<void>;
+    /** Recherche des points relais à proximité */
+    getRelayPoints(postalCode: string, countryCode?: string, shippingModeGuid?: string): Promise<PickupPoint[]>;
+}
+
+/** Mode de gestion du stock : 0=Aucun, 1=Géré, 2=Infini */
+export declare type StockManagementMode = 0 | 1 | 2;
+
+export declare interface StoreEvent {
+    id: string;
+    storeId: string;
+    /** Date au format 'YYYY-MM-DD' */
+    eventDate: string;
+    category?: string | null;
+    title?: string | null;
+    htmlDescription?: string | null;
+    isArchived: boolean;
+    crossChannelEventId?: string | null;
+    exceptionalOpeningHours?: string | null;
+}
+
+export declare interface StoreOpeningHours {
+    storeGuid: string;
+    day: DayOfWeek;
+    openingHoursPeriod1?: string | null;
+    openingHoursPeriod2?: string | null;
+}
+
+declare class StoresModule {
+    private readonly http;
+    private readonly cache;
+    constructor(http: CommerceHttpAdapter, cache: CacheStrategy);
+    /** Recherche des magasins par coordonnées géographiques */
+    findByLocation(latitude: number, longitude: number, radiusKm?: number): Promise<StoreWithOpeningHours[]>;
+    /** Recherche des magasins par code postal */
+    findByPostalCode(postalCode: string, countryCode?: string): Promise<StoreWithOpeningHours[]>;
+    /** Récupère le détail d'un magasin par son GUID */
+    getStore(storeGuid: string): Promise<StoreWithOpeningHours>;
+}
+
+export declare interface StoreWithOpeningHours {
+    guid: string;
+    code?: string | null;
+    label?: string | null;
+    streetAddress?: string | null;
+    postalCode?: string | null;
+    city?: string | null;
+    countryIso3LettersCode?: string | null;
+    latitude?: number | null;
+    longitude?: number | null;
+    geoZone?: string | null;
+    phone?: string | null;
+    email?: string | null;
+    messageForClients?: string | null;
+    isClickNMortarEnable: boolean;
+    isShippingDestination: boolean;
+    acceptsPickup: boolean;
+    acceptsShipFromStore: boolean;
+    storeType?: string | null;
+    openingDate?: string | null;
+}
+
+/** Produit web (utilisé dans les listings et résultats de recherche) */
+export declare interface WebProduct {
+    id: number;
+    guid: string;
+    priceWOTax: number;
+    /** Prix TTC */
+    price: number;
+    vat: number;
+    discountedPriceWOTax?: number | null;
+    discountedPrice?: number | null;
+    discountStartDate?: string | null;
+    discountEndDate?: string | null;
+    creationDate: string;
+    label?: string | null;
+    sku?: string | null;
+    familyId: number;
+    description?: string | null;
+    subFamilyId?: number | null;
+    brandId: number;
+    vatId: number;
+    productTypeId: number;
+    usableOnDigitalTools: boolean;
+    isForInvoicableElements: boolean;
+    isMultiVariations: boolean;
+    isMainVariation: boolean;
+    isAssembly: boolean;
+    isExternalVendorEnabled: boolean;
+    isProductComplete: boolean;
+    currentCreationStep: number;
+    recommendedPriceWOTax?: number | null;
+    recommendedPrice?: number | null;
+    metaType: ProductMetaType;
+    riskScore: number;
+    parentProductId?: number | null;
+    isHighDemand: boolean;
+    isShippable: boolean;
+    isSubscription: boolean;
+    isPackage: boolean;
+    isImported: boolean;
+    allowsDecimalQuantity: boolean;
+    externalCode?: string | null;
+    compositionType?: string | null;
+    isSimplified: boolean;
+    lockedByUserId?: string | null;
+    unitId?: number | null;
+    quantityPerUnit?: number | null;
+    stockManagementMode: StockManagementMode;
+    priceIndexId?: string | null;
+    priceIndexMultiplier?: number | null;
+    priceIndexFeesRate?: number | null;
+    externalDppUrl?: string | null;
+    mainImage?: string | null;
+    smallImage?: string | null;
+    intermediateImage?: string | null;
+    availableForOrder: boolean;
+    availableForShipping: boolean;
+    availableForPickup: boolean;
+    allTags?: string[] | null;
+    externalUrl?: string | null;
+    mainCategoryId?: number | null;
+    availabilityThreshold?: number | null;
+    limitedAvailabilityThreshold?: number | null;
+    reviewsNote?: number | null;
+    qtyByParentUnit: number;
+    reasonCode?: string | null;
+    relevance: number;
+    attributs?: Record<string, string | null> | null;
+    attributsPrives?: Record<string, string | null> | null;
+    importance: number;
+}
+
+/**
+ * Abstraction du canal de communication avec le SharedWorker de cache.
+ *
+ * - Utilise un SharedWorker si le navigateur le supporte
+ * - Fallback : Map in-memory (données non persistantes, perdues au reload)
+ *
+ * Chaque appel retourne une Promise, résolue/rejetée via la réponse du worker.
+ */
+declare class WorkerBridge {
+    private port;
+    private readonly pending;
+    private requestCounter;
+    private readonly fallback;
+    private readonly usingFallback;
+    constructor();
+    private tryStartWorker;
+    private readonly handleMessage;
+    private nextId;
+    private send;
+    get<T>(key: string): Promise<T | null>;
+    set(key: string, data: unknown, ttlMs: number): Promise<void>;
+    invalidate(pattern: string): Promise<void>;
+    clearAll(): Promise<void>;
+    dispose(): void;
+}
+
+export { }