@smess/networking 1.0.29 → 1.1.0

package/dist/services/storefront.customer.metadata.service.test.js

@@ -0,0 +1,271 @@
+import { StorefrontCustomerMetadataService, StorefrontCustomerMetadataProvider, } from "./storefront.customer.metadata.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of, BehaviorSubject } from "rxjs";
+describe("StorefrontCustomerMetadataService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        version: "api/v1",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    let $authToken;
+    beforeEach(() => {
+        $authToken = new BehaviorSubject(null);
+        service = new StorefrontCustomerMetadataService(config, $authToken);
+    });
+    describe("StorefrontCustomerMetadataProvider", () => {
+        it("should generate correct path for metadata-get", () => {
+            const provider = new StorefrontCustomerMetadataProvider(config, "metadata-get", $authToken);
+            expect(provider.path).toBe("/storefront/customer/metadata");
+            expect(provider.method).toBe("GET");
+        });
+        it("should generate correct path for favorites-add", () => {
+            const provider = new StorefrontCustomerMetadataProvider(config, "favorites-add", $authToken);
+            expect(provider.path).toBe("/storefront/customer/favorites");
+            expect(provider.method).toBe("POST");
+        });
+        it("should generate correct path for favorites-update-category", () => {
+            const provider = new StorefrontCustomerMetadataProvider(config, "favorites-update-category", $authToken);
+            expect(provider.path).toBe("/storefront/customer/favorites/${productId}/category");
+            expect(provider.method).toBe("PUT");
+            expect(provider.getPath(123)).toBe("/storefront/customer/favorites/123/category");
+        });
+        it("should include auth token in headers", () => {
+            $authToken.next("test-auth-token");
+            const provider = new StorefrontCustomerMetadataProvider(config, "metadata-get", $authToken);
+            const headers = provider.headers;
+            expect(headers["Authorization"]).toBe("Bearer test-auth-token");
+        });
+    });
+    describe("getMetadata", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const result = await service.getMetadata(1).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+        });
+        it("should get metadata successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const response = {
+                data: { customerId: "123", preferences: {} },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getMetadata(1).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("addFavorite", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const payload = { productId: 123 };
+            const result = await service.addFavorite(1, payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+        });
+        it("should add favorite successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const payload = { productId: 123 };
+            const response = {
+                data: { id: 1, productId: 123 },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.addFavorite(1, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("listFavorites", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const result = await service.listFavorites(1).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+        });
+        it("should list favorites successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const response = {
+                data: { favorites: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.listFavorites(1).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should list favorites with category filter", async () => {
+            $authToken.next("test-auth-token");
+            const response = {
+                data: { favorites: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service
+                .listFavorites(1, "Electronics")
+                .toPromise();
+            expect(result?.hasSuccess).toBe(true);
+        });
+    });
+    describe("updateFavoriteCategory", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const payload = { category: "Books" };
+            const result = await service
+                .updateFavoriteCategory(123, 1, payload)
+                .toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+        });
+        it("should update favorite category successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const payload = { category: "Books" };
+            const response = {
+                data: { id: 1, category: "Books" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, productId) => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service
+                .updateFavoriteCategory(123, 1, payload)
+                .toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("removeFavorite", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const result = await service.removeFavorite(123, 1).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+        });
+        it("should remove favorite successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const response = {
+                data: { message: "Favorite removed" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, productId) => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.removeFavorite(123, 1).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("listFavoriteCategories", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const result = await service.listFavoriteCategories(1).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+        });
+        it("should list favorite categories successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const response = {
+                data: { categories: ["Books", "Electronics"] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.listFavoriteCategories(1).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("updatePreferences", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const payload = { preferences: {} };
+            const result = await service.updatePreferences(1, payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+        });
+        it("should update preferences successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const payload = {
+                preferences: { theme: "dark" },
+            };
+            const response = {
+                data: { preferences: { theme: "dark" } },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.updatePreferences(1, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("recordProductView", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const payload = { productId: 123 };
+            const result = await service.recordProductView(1, payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+        });
+        it("should record product view successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const payload = { productId: 123 };
+            const response = {
+                data: { message: "Product view recorded" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.recordProductView(1, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getRecentSearches", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const result = await service.getRecentSearches(1).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+        });
+        it("should get recent searches successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const response = {
+                data: { searches: ["laptop", "phone"] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getRecentSearches(1).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getRecentlyViewed", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const result = await service.getRecentlyViewed(1).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+        });
+        it("should get recently viewed successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const response = {
+                data: { products: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getRecentlyViewed(1).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should get recently viewed with limit", async () => {
+            $authToken.next("test-auth-token");
+            const response = {
+                data: { products: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getRecentlyViewed(1, 10).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+        });
+    });
+});

package/dist/services/storefront.order.service.d.ts

@@ -0,0 +1,45 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type StorefrontOrderTarget = "order-list" | "order-detail" | "order-track";
+export interface OrderListRequest {
+    page?: number;
+    limit?: number;
+    status?: string;
+}
+export interface TrackOrderRequest {
+    orderNumber: string;
+    email: string;
+}
+export declare class StorefrontOrderProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: StorefrontOrderTarget, $authToken: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export declare class StorefrontOrderService {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: StorefrontOrderTarget): SmessService<StorefrontOrderProvider>;
+    /**
+     * List customer orders (requires authentication)
+     * GET /storefront/orders
+     */
+    listOrders(params?: OrderListRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Get order details (requires authentication)
+     * GET /storefront/orders/{id}
+     */
+    getOrderDetail(id: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Track guest order (no authentication required)
+     * POST /storefront/orders/track
+     */
+    trackOrder(payload: TrackOrderRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

package/dist/services/storefront.order.service.js

@@ -0,0 +1,99 @@
+import { NetworkingUIEventWrapped, AlertModel, AlertButtonModel, } from "../types/types";
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+import { of } from "rxjs";
+export class StorefrontOrderProvider {
+    constructor(config, target, $authToken) {
+        this.config = config;
+        this.target = target;
+        this.$authToken = $authToken;
+    }
+    get baseURL() {
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case "order-list":
+                return "/storefront/orders";
+            case "order-detail":
+                return "/storefront/orders/${id}";
+            case "order-track":
+                return "/storefront/orders/track";
+            default:
+                return "/storefront/orders";
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case "order-list":
+            case "order-detail":
+                return "GET";
+            case "order-track":
+                return "POST";
+            default:
+                return "GET";
+        }
+    }
+    get headers() {
+        // For order-track, don't include auth token (public endpoint)
+        const authToken = this.target === "order-track" ? null : this.$authToken.value;
+        let headers = SmessService.getHeaders(Accept.V1, authToken);
+        if (this.config.clientId) {
+            headers[SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            headers[SMESSHeader.ApiKey] = this.config.apiKey;
+        }
+        return SmessService.filterHeaders(headers);
+    }
+    getPath(...queryParams) {
+        let definedPath = this.path;
+        const params = definedPath.match(/\$\{(.+?)\}/g);
+        params?.forEach((value, index) => {
+            definedPath = definedPath.replace(value, String(queryParams[index]));
+        });
+        return definedPath;
+    }
+}
+export class StorefrontOrderService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new StorefrontOrderProvider(this.config, target, this.$authToken);
+        return new SmessService(targetWrapper);
+    }
+    /**
+     * List customer orders (requires authentication)
+     * GET /storefront/orders
+     */
+    listOrders(params) {
+        // Check authentication
+        if (!this.$authToken.value) {
+            const alertModel = new AlertModel("Authentication required to list orders", 401, true, "Authentication Required", null, [AlertButtonModel.buttonYes()]);
+            return of(NetworkingUIEventWrapped.failed(alertModel));
+        }
+        return this.provider("order-list").request(params);
+    }
+    /**
+     * Get order details (requires authentication)
+     * GET /storefront/orders/{id}
+     */
+    getOrderDetail(id) {
+        // Check authentication
+        if (!this.$authToken.value) {
+            const alertModel = new AlertModel("Authentication required to view order details", 401, true, "Authentication Required", null, [AlertButtonModel.buttonYes()]);
+            return of(NetworkingUIEventWrapped.failed(alertModel));
+        }
+        return this.provider("order-detail").request(null, undefined, id);
+    }
+    /**
+     * Track guest order (no authentication required)
+     * POST /storefront/orders/track
+     */
+    trackOrder(payload) {
+        return this.provider("order-track").request(payload);
+    }
+}

package/dist/services/storefront.order.service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/storefront.order.service.test.js

@@ -0,0 +1,158 @@
+import { StorefrontOrderService, StorefrontOrderProvider, } from "./storefront.order.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of, BehaviorSubject } from "rxjs";
+describe("StorefrontOrderService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        version: "api/v1",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    let $authToken;
+    beforeEach(() => {
+        $authToken = new BehaviorSubject(null);
+        service = new StorefrontOrderService(config, $authToken);
+    });
+    describe("StorefrontOrderProvider", () => {
+        it("should generate correct path for order-list", () => {
+            const provider = new StorefrontOrderProvider(config, "order-list", $authToken);
+            expect(provider.path).toBe("/storefront/orders");
+            expect(provider.method).toBe("GET");
+        });
+        it("should generate correct path for order-detail", () => {
+            const provider = new StorefrontOrderProvider(config, "order-detail", $authToken);
+            expect(provider.path).toBe("/storefront/orders/${id}");
+            expect(provider.method).toBe("GET");
+            expect(provider.getPath(123)).toBe("/storefront/orders/123");
+        });
+        it("should generate correct path for order-track", () => {
+            const provider = new StorefrontOrderProvider(config, "order-track", $authToken);
+            expect(provider.path).toBe("/storefront/orders/track");
+            expect(provider.method).toBe("POST");
+        });
+        it("should include auth token in headers for authenticated endpoints", () => {
+            $authToken.next("test-auth-token");
+            const provider = new StorefrontOrderProvider(config, "order-list", $authToken);
+            const headers = provider.headers;
+            expect(headers["Authorization"]).toBe("Bearer test-auth-token");
+        });
+        it("should not include auth token for order-track", () => {
+            $authToken.next("test-auth-token");
+            const provider = new StorefrontOrderProvider(config, "order-track", $authToken);
+            const headers = provider.headers;
+            expect(headers["Authorization"]).toBeUndefined();
+        });
+    });
+    describe("listOrders", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const result = await service.listOrders().toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+            expect(result?.alertModel?.message).toContain("Authentication required");
+        });
+        it("should list orders successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const params = {
+                page: 1,
+                limit: 20,
+                status: "completed",
+            };
+            const response = {
+                data: { orders: [], total: 0 },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.listOrders(params).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle list orders error when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.listOrders().toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("getOrderDetail", () => {
+        it("should return authentication error when not authenticated", async () => {
+            const result = await service.getOrderDetail(123).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+            expect(result?.alertModel?.httpErrorCode).toBe(401);
+            expect(result?.alertModel?.message).toContain("Authentication required");
+        });
+        it("should get order detail successfully when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const response = {
+                data: { id: 123, status: "completed" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getOrderDetail(123).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle get order detail error when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.getOrderDetail(123).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("trackOrder", () => {
+        it("should track order successfully without authentication", async () => {
+            const payload = {
+                orderNumber: "ORD-12345",
+                email: "customer@example.com",
+            };
+            const response = {
+                data: { id: 123, status: "shipped" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.trackOrder(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle track order error", async () => {
+            const payload = {
+                orderNumber: "ORD-12345",
+                email: "customer@example.com",
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.trackOrder(payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+        it("should track order even when authenticated", async () => {
+            $authToken.next("test-auth-token");
+            const payload = {
+                orderNumber: "ORD-67890",
+                email: "user@example.com",
+            };
+            const response = {
+                data: { id: 456, status: "delivered" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.trackOrder(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+});

package/dist/services/storefront.product.service.d.ts

@@ -0,0 +1,52 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { Observable } from "rxjs";
+export type StorefrontProductTarget = "product-list" | "product-collection" | "product-detail";
+export interface ProductListRequest {
+    page?: number;
+    limit?: number;
+    store_id?: number;
+    category?: string;
+    sub_category?: string;
+    min_price?: number;
+    max_price?: number;
+    in_stock?: boolean;
+    search?: string;
+}
+export interface StorefrontProductCollectionRequest extends ProductListRequest {
+    per_page?: number;
+    only_promoted?: boolean;
+    only_discounted?: boolean;
+    include_hidden?: boolean;
+    only_featured?: boolean;
+}
+export declare class StorefrontProductProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    constructor(config: NetworkingConfig, target: StorefrontProductTarget);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export declare class StorefrontProductService {
+    private readonly config;
+    constructor(config: NetworkingConfig);
+    provider(target: StorefrontProductTarget): SmessService<StorefrontProductProvider>;
+    /**
+     * List products with pagination and filtering
+     * GET /storefront/products
+     */
+    listProducts(params?: ProductListRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Get product collection with per_page pagination style
+     * GET /storefront/products/collection
+     */
+    getProductCollection(params?: StorefrontProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Get product details by ID
+     * GET /storefront/products/{id}
+     */
+    getProductDetail(id: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}