@smess/networking 1.2.0 → 2.1.0

package/dist/services/store.cart.service.js

@@ -1,177 +0,0 @@
-import { Accept, SMESSHeader, SmessService } from "./smess.service";
-import { BehaviorSubject } from "rxjs";
-import { tap } from "rxjs/operators";
-export class StoreCartProvider {
-    constructor(config, target, $cartHash, $storeId) {
-        this.config = config;
-        this.target = target;
-        this.$cartHash = $cartHash;
-        this.$storeId = $storeId;
-    }
-    get baseURL() {
-        return this.config.version
-            ? `${this.config.baseUrl}/${this.config.version}`
-            : this.config.baseUrl;
-    }
-    get path() {
-        switch (this.target) {
-            case "cart-get":
-                return "/store/cart";
-            case "cart-update":
-                return "/store/cart";
-            case "cart-add-item":
-                return "/store/cart/items";
-            case "cart-update-item":
-                return "/store/cart/items/\${id}";
-            case "cart-delete-item":
-                return "/store/cart/items/\${id}";
-            case "cart-delete-all-items":
-                return "/store/cart/items";
-            case "cart-batch-items":
-                return "/store/cart/items/batch";
-            default:
-                return "/store/cart";
-        }
-    }
-    get method() {
-        switch (this.target) {
-            case "cart-get":
-                return "GET";
-            case "cart-update":
-                return "PUT";
-            case "cart-add-item":
-                return "POST";
-            case "cart-update-item":
-                return "PUT";
-            case "cart-delete-item":
-                return "DELETE";
-            case "cart-delete-all-items":
-                return "DELETE";
-            case "cart-batch-items":
-                return "POST";
-            default:
-                return "GET";
-        }
-    }
-    get headers() {
-        let headers = SmessService.getHeaders(Accept.V1, null);
-        if (this.config.clientId) {
-            headers[SMESSHeader.ClientId] = this.config.clientId;
-        }
-        if (this.config.apiKey) {
-            headers[SMESSHeader.ApiKey] = this.config.apiKey;
-        }
-        const filteredHeaders = SmessService.filterHeaders(headers);
-        // Add X-Nonce-Token header if cartHash is available
-        if (this.$cartHash.value) {
-            filteredHeaders["X-Nonce-Token"] = this.$cartHash.value;
-        }
-        // Add X-Store-Id header if storeId is available
-        if (this.$storeId.value) {
-            filteredHeaders["X-Store-Id"] = this.$storeId.value;
-        }
-        return filteredHeaders;
-    }
-    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 StoreCartService {
-    constructor(config, $storeId) {
-        this.config = config;
-        this.$cartHash = new BehaviorSubject(null);
-        // Use the provided BehaviorSubject or create a new one
-        this.$storeId = $storeId || new BehaviorSubject(null);
-    }
-    // Getter to access the current cart hash
-    get currentCartHash() {
-        return this.$cartHash.value;
-    }
-    // Getter to access the cart hash as observable
-    get cartHash$() {
-        return this.$cartHash;
-    }
-    // Getter to access the current store ID
-    get currentStoreId() {
-        return this.$storeId.value;
-    }
-    // Getter to access the store ID as observable
-    get storeId$() {
-        return this.$storeId;
-    }
-    // Method to update the store ID
-    setStoreId(storeId) {
-        this.$storeId.next(storeId);
-    }
-    provider(target) {
-        const targetWrapper = new StoreCartProvider(this.config, target, this.$cartHash, this.$storeId);
-        return new SmessService(targetWrapper);
-    }
-    /**
-     * Update the cart hash from cart response
-     */
-    updateCartHash(result) {
-        if (result.hasSuccess && result.response) {
-            const response = result.response;
-            // Try to extract cartHash from different possible structures
-            const cartHash = response.data?.cartHash || response.cartHash;
-            if (cartHash) {
-                this.$cartHash.next(cartHash);
-            }
-        }
-    }
-    /**
-     * Get the current cart
-     * GET api/v1/store/cart
-     */
-    getCart() {
-        return this.provider("cart-get").request().pipe(tap((result) => this.updateCartHash(result)));
-    }
-    /**
-     * Update cart (e.g., add notes, apply coupon)
-     * PUT api/v1/store/cart
-     */
-    updateCart(payload) {
-        return this.provider("cart-update").request(payload).pipe(tap((result) => this.updateCartHash(result)));
-    }
-    /**
-     * Add item to cart
-     * POST api/v1/store/cart/items
-     */
-    addItem(payload) {
-        return this.provider("cart-add-item").request(payload).pipe(tap((result) => this.updateCartHash(result)));
-    }
-    /**
-     * Batch create/update items in cart
-     * POST api/v1/store/cart/items/batch
-     */
-    batchItems(payload) {
-        return this.provider("cart-batch-items").request(payload).pipe(tap((result) => this.updateCartHash(result)));
-    }
-    /**
-     * Update item quantity in cart
-     * PUT api/v1/store/cart/items/{id}
-     */
-    updateItemQuantity(itemId, payload) {
-        return this.provider("cart-update-item").request(payload, undefined, itemId).pipe(tap((result) => this.updateCartHash(result)));
-    }
-    /**
-     * Delete item from cart
-     * DELETE api/v1/store/cart/items/{id}
-     */
-    deleteItem(itemId) {
-        return this.provider("cart-delete-item").request(undefined, undefined, itemId);
-    }
-    /**
-     * Delete all items from cart
-     * DELETE api/v1/store/cart/items
-     */
-    deleteAllItems() {
-        return this.provider("cart-delete-all-items").request();
-    }
-}

package/dist/services/store.cart.service.test.d.ts

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

package/dist/services/store.cart.service.test.js

@@ -1,394 +0,0 @@
-import { StoreCartService, StoreCartProvider, } from "./store.cart.service";
-import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
-import { BehaviorSubject, of } from "rxjs";
-describe("StoreCartService", () => {
-    const config = {
-        baseUrl: "https://api.example.com",
-        isProd: false,
-        clientId: "test-client-id",
-        apiKey: "test-api-key",
-    };
-    let service;
-    beforeEach(() => {
-        service = new StoreCartService(config);
-    });
-    it("should initialize with null cartHash and storeId", () => {
-        expect(service.currentCartHash).toBe(null);
-        expect(service.cartHash$.value).toBe(null);
-        expect(service.currentStoreId).toBe(null);
-        expect(service.storeId$.value).toBe(null);
-    });
-    it("should initialize with provided storeId BehaviorSubject", () => {
-        const storeId = "store-123";
-        const $storeId = new BehaviorSubject(storeId);
-        const serviceWithStore = new StoreCartService(config, $storeId);
-        expect(serviceWithStore.currentStoreId).toBe(storeId);
-        expect(serviceWithStore.storeId$.value).toBe(storeId);
-    });
-    it("should update storeId dynamically", () => {
-        expect(service.currentStoreId).toBe(null);
-        service.setStoreId("store-456");
-        expect(service.currentStoreId).toBe("store-456");
-        expect(service.storeId$.value).toBe("store-456");
-    });
-    describe("getCart", () => {
-        it("should get cart successfully and update cartHash", async () => {
-            const cart = {
-                dateCreated: "2025-10-14 12:56:31",
-                dateModified: "2025-10-14 12:56:31",
-                discountTotal: 0,
-                discountTax: 0,
-                shippingTotal: 0,
-                shippingTax: 0,
-                cartTax: 0,
-                total: 20.0,
-                totalTax: 0,
-                customerId: "cust-123",
-                billingInformation: null,
-                shippingInformation: null,
-                paymentMethod: "cash",
-                deliveryType: "pickup",
-                transactionId: null,
-                customerIpAddress: "172.18.0.1",
-                customerUserAgent: "Test Agent",
-                customerNote: null,
-                cartHash: "test-hash-123",
-                cartItems: [
-                    {
-                        id: "item-1",
-                        productId: "prod-1",
-                        name: "Test Product",
-                        quantity: 2,
-                        price: 10.0,
-                        total: 20.0,
-                    },
-                ],
-                paymentUrl: null,
-                store: null,
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(cart)),
-            });
-            const result = await service.getCart().toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(cart);
-            expect(service.currentCartHash).toBe("test-hash-123");
-        });
-        it("should handle getCart error", async () => {
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.getCart().toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("updateCart", () => {
-        it("should update cart successfully", async () => {
-            const payload = {
-                status: "submitted",
-                customer_note: "Customer Note Example",
-                customer_id: "f1df6e9a-0160-11f0-82c2-6cac1a7e2953",
-                payment_method: "bank_transfer",
-                delivery_type: "delivery",
-                billing_information: {
-                    email: "billing@example.com",
-                    phone_number: "+1-555-111-2222",
-                    street: "456 Market Street",
-                    city: "san_francisco",
-                    postal_code: "94103",
-                    state: "ca",
-                    country: "us",
-                },
-                shipping_information: {
-                    email: "john.doe@example.com",
-                    phone_number: "+1-555-123-4567",
-                    street: "123 Main Street",
-                    city: "san_francisco",
-                    postal_code: "94105",
-                    state: "ca",
-                    country: "us",
-                },
-            };
-            const cart = {
-                dateCreated: "2025-10-14 12:56:31",
-                dateModified: "2025-10-14 12:56:31",
-                discountTotal: 0,
-                discountTax: 0,
-                shippingTotal: 0,
-                shippingTax: 0,
-                cartTax: 0,
-                total: 0,
-                totalTax: 0,
-                customerId: null,
-                billingInformation: null,
-                shippingInformation: null,
-                paymentMethod: "cash",
-                deliveryType: "pickup",
-                transactionId: null,
-                customerIpAddress: "172.18.0.1",
-                customerUserAgent: "Test Agent",
-                customerNote: "Please deliver in the evening",
-                cartHash: "test-hash",
-                cartItems: [],
-                paymentUrl: null,
-                store: null,
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(cart)),
-            });
-            const result = await service.updateCart(payload).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(cart);
-        });
-        it("should handle updateCart error", async () => {
-            const payload = {
-                status: "invalid_status",
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.updateCart(payload).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("addItem", () => {
-        it("should add item to cart successfully", async () => {
-            const payload = {
-                product_id: "prod-123",
-                quantity: 3,
-            };
-            const cart = {
-                dateCreated: "2025-10-14 12:56:31",
-                dateModified: "2025-10-14 12:56:31",
-                discountTotal: 0,
-                discountTax: 0,
-                shippingTotal: 0,
-                shippingTax: 0,
-                cartTax: 0,
-                total: 45.0,
-                totalTax: 0,
-                customerId: null,
-                billingInformation: null,
-                shippingInformation: null,
-                paymentMethod: "cash",
-                deliveryType: "pickup",
-                transactionId: null,
-                customerIpAddress: "172.18.0.1",
-                customerUserAgent: "Test Agent",
-                customerNote: null,
-                cartHash: "test-hash",
-                cartItems: [
-                    {
-                        id: "item-1",
-                        productId: "prod-123",
-                        quantity: 3,
-                        price: 15.0,
-                        total: 45.0,
-                    },
-                ],
-                paymentUrl: null,
-                store: null,
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(cart)),
-            });
-            const result = await service.addItem(payload).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(cart);
-        });
-        it("should handle addItem error", async () => {
-            const payload = {
-                product_id: "prod-999",
-                quantity: 1,
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.addItem(payload).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("batchItems", () => {
-        it("should batch create/update items successfully and update cartHash", async () => {
-            const payload = {
-                create: [
-                    { product_id: "prod-111", quantity: 2 },
-                    { product_id: "prod-222", quantity: 1 },
-                ],
-                update: [
-                    { product_id: "prod-333", quantity: 5 },
-                ],
-            };
-            const cart = {
-                dateCreated: "2025-10-14 12:56:31",
-                dateModified: "2025-10-14 12:56:31",
-                discountTotal: 0,
-                discountTax: 0,
-                shippingTotal: 0,
-                shippingTax: 0,
-                cartTax: 0,
-                total: 100.0,
-                totalTax: 0,
-                customerId: null,
-                billingInformation: null,
-                shippingInformation: null,
-                paymentMethod: "cash",
-                deliveryType: "pickup",
-                transactionId: null,
-                customerIpAddress: "172.18.0.1",
-                customerUserAgent: "Test Agent",
-                customerNote: null,
-                cartHash: "hash-batch-123",
-                cartItems: [
-                    { id: "item-1", productId: "prod-111", quantity: 2, price: 10, total: 20 },
-                    { id: "item-2", productId: "prod-222", quantity: 1, price: 30, total: 30 },
-                    { id: "item-3", productId: "prod-333", quantity: 5, price: 10, total: 50 },
-                ],
-                paymentUrl: null,
-                store: null,
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(cart)),
-            });
-            const result = await service.batchItems(payload).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(cart);
-            expect(service.currentCartHash).toBe("hash-batch-123");
-        });
-        it("should handle batchItems error", async () => {
-            const payload = {
-                create: [{ product_id: "invalid", quantity: 0 }],
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.batchItems(payload).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("updateItemQuantity", () => {
-        it("should update item quantity successfully", async () => {
-            const itemId = "item-123";
-            const payload = {
-                quantity: 5,
-            };
-            const cart = {
-                dateCreated: "2025-10-14 12:56:31",
-                dateModified: "2025-10-14 12:56:31",
-                discountTotal: 0,
-                discountTax: 0,
-                shippingTotal: 0,
-                shippingTax: 0,
-                cartTax: 0,
-                total: 75.0,
-                totalTax: 0,
-                customerId: null,
-                billingInformation: null,
-                shippingInformation: null,
-                paymentMethod: "cash",
-                deliveryType: "pickup",
-                transactionId: null,
-                customerIpAddress: "172.18.0.1",
-                customerUserAgent: "Test Agent",
-                customerNote: null,
-                cartHash: "test-hash",
-                cartItems: [
-                    {
-                        id: itemId,
-                        productId: "prod-123",
-                        quantity: 5,
-                        price: 15.0,
-                        total: 75.0,
-                    },
-                ],
-                paymentUrl: null,
-                store: null,
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(cart)),
-            });
-            const result = await service.updateItemQuantity(itemId, payload).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(cart);
-        });
-        it("should handle updateItemQuantity error", async () => {
-            const itemId = "item-999";
-            const payload = {
-                quantity: 5,
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.updateItemQuantity(itemId, payload).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("deleteItem", () => {
-        it("should delete item from cart successfully", async () => {
-            const itemId = "item-123";
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(undefined)),
-            });
-            const result = await service.deleteItem(itemId).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-        });
-        it("should handle deleteItem error", async () => {
-            const itemId = "item-999";
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.deleteItem(itemId).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("deleteAllItems", () => {
-        it("should delete all items from cart successfully", async () => {
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(undefined)),
-            });
-            const result = await service.deleteAllItems().toPromise();
-            expect(result?.hasSuccess).toBe(true);
-        });
-        it("should handle deleteAllItems error", async () => {
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.deleteAllItems().toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("headers", () => {
-        it("should include X-Store-Id header when storeId is set", () => {
-            const storeId = "store-123";
-            const cartHash = "cart-hash-456";
-            const $cartHashSubject = new BehaviorSubject(cartHash);
-            const $storeIdSubject = new BehaviorSubject(storeId);
-            const provider = new StoreCartProvider(config, "cart-get", $cartHashSubject, $storeIdSubject);
-            const headers = provider.headers;
-            expect(headers["X-Store-Id"]).toBe(storeId);
-            expect(headers["X-Nonce-Token"]).toBe(cartHash);
-        });
-        it("should not include X-Store-Id header when storeId is null", () => {
-            const $cartHashSubject = new BehaviorSubject(null);
-            const $storeIdSubject = new BehaviorSubject(null);
-            const provider = new StoreCartProvider(config, "cart-get", $cartHashSubject, $storeIdSubject);
-            const headers = provider.headers;
-            expect(headers["X-Store-Id"]).toBeUndefined();
-        });
-        it("should include X-Nonce-Token header when cartHash is set", () => {
-            const cartHash = "cart-hash-789";
-            const $cartHashSubject = new BehaviorSubject(cartHash);
-            const $storeIdSubject = new BehaviorSubject(null);
-            const provider = new StoreCartProvider(config, "cart-get", $cartHashSubject, $storeIdSubject);
-            const headers = provider.headers;
-            expect(headers["X-Nonce-Token"]).toBe(cartHash);
-        });
-    });
-});

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

@@ -1,124 +0,0 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
-import { SmessService } from "./smess.service";
-import { Observable } from "rxjs";
-export type StoreProductTarget = "featured-product-list" | "featured-product-list-by-store" | "product-category-list" | "product-get-by-id" | "product-collection" | "product-collection-by-store";
-export interface StoreProductCollectionRequest {
-    page?: number;
-    per_page?: number;
-    search?: string;
-    sort_by?: string;
-    category?: string;
-    group?: string;
-    min_price?: number;
-    max_price?: number;
-    only_discounted?: boolean;
-    unit?: string;
-    supplier?: string;
-    has_offer?: boolean;
-    [key: string]: unknown;
-}
-export interface PaginationLinks {
-    first: string;
-    last: string;
-    next?: string;
-    prev?: string;
-}
-export interface StoreProduct {
-    id: string;
-    barcode: string;
-    expiryDate: string | null;
-    name: string;
-    category: string;
-    subCategory: string | null;
-    vatInPercent: number;
-    unit: string;
-    volume: number | null;
-    quantity: number;
-    unitWeight: number | null;
-    articleWeight: number | null;
-    tareWeight: number | null;
-    supplier: string | null;
-    supplierCode: string | null;
-    supplierItemName: string | null;
-    picture: string;
-    slug: string;
-    internalCode: string;
-    htmlDescription: string | null;
-    inventory: boolean;
-    quantityInStock: number;
-    minimumStockQuantity: number;
-    pricePurchase: number;
-    priceToSell: number;
-    discountInPercent: number;
-    priceAfterDiscount: number;
-    priceByWeight: boolean;
-    [key: string]: unknown;
-}
-export interface StoreProductCollectionResponse {
-    links: PaginationLinks;
-    items: StoreProduct[];
-    count: number;
-    total: number;
-    page: number;
-    totalPage: number;
-    perPage: number;
-    metadata: unknown[];
-}
-export interface ProductCategory {
-    name: string;
-    numberOfProducts: number;
-    image: string | null;
-}
-export declare class StoreProductProvider implements ProviderType {
-    private readonly config;
-    private readonly target;
-    constructor(config: NetworkingConfig, target: StoreProductTarget);
-    get baseURL(): string;
-    get path(): string;
-    get method(): string;
-    get headers(): Record<string, string>;
-    getPath(...queryParams: unknown[]): string;
-}
-export interface StoreProductServiceType {
-    getFeaturedProductList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    getFeaturedProductListByStore(storeId: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    getProductCategoryList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    getProductById(productId: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    getProductCollection(payload?: StoreProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    getProductCollectionByStore(storeId: string, payload?: StoreProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-}
-export declare class StoreProductService implements StoreProductServiceType {
-    private readonly config;
-    constructor(config: NetworkingConfig);
-    provider(target: StoreProductTarget): SmessService<StoreProductProvider>;
-    /**
-     * Get featured product list
-     * GET /api/v1/store/featured-product-list
-     */
-    getFeaturedProductList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Get featured product list by store
-     * GET /api/v1/store/{id}/featured-product-list
-     */
-    getFeaturedProductListByStore(storeId: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Get product category list
-     * GET /api/v1/store/product-category/list
-     */
-    getProductCategoryList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Get product by ID
-     * GET /api/v1/store/product/{id}
-     */
-    getProductById(productId: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Get product collection
-     * GET /api/v1/store/product-collection
-     */
-    getProductCollection(payload?: StoreProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Get product collection by store
-     * GET /api/v1/store/{id}/product-collection
-     */
-    getProductCollectionByStore(storeId: string, payload?: StoreProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-}