@infrab4a/connect-angular 6.0.0-alpha.0 → 6.0.0-beta.0

package/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './mobile-operation-system-checker.helper';

package/helpers/mobile-operation-system-checker.helper.d.ts

@@ -0,0 +1,3 @@
+export declare class MobileOperationSystemCheckerHelper {
+    static isAppleDevice(): boolean;
+}

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from './angular-connect.module';
+export * from './angular-firebase-auth.module';
+export * from './angular-firestore.module';
+export * from './angular-hasura-graphql.module';
+export * from './persistence';
+export * from './services';

package/interfaces/catalog-strategies.interface.d.ts

@@ -0,0 +1,31 @@
+import { Category, Product, ProductGender, RepositoryCacheOptions, RepositoryFindResult, Shops } from '@infrab4a/connect';
+export interface CatalogSearchParams {
+    category?: Category;
+    profile?: string[];
+    term?: string;
+    filters?: CatalogFilters;
+    mainGender?: ProductGender;
+    limits: {
+        limit?: number;
+        offset?: number;
+    };
+    sort?: string;
+}
+export interface CatalogFilters {
+    clubDiscount?: number[];
+    brands?: string[];
+    prices?: {
+        min?: number;
+        max?: number;
+        subscriberPrice?: boolean;
+    };
+    gender?: ProductGender[];
+    rate?: number;
+    customOptions?: string[];
+    tags?: string[];
+}
+export interface CatalogSearchStrategy {
+    search(params: CatalogSearchParams, shop: Shops, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<RepositoryFindResult<Product>>;
+}

package/interfaces/category-facades.interface.d.ts

@@ -0,0 +1,6 @@
+import { CategoryRepository, ProductSearchIndex, ProductStockNotificationRepository } from '@infrab4a/connect';
+export interface ProductServicesFacade {
+    productStockNotificationRepository: ProductStockNotificationRepository;
+    categoryRepository: CategoryRepository;
+    productSearch: ProductSearchIndex;
+}

package/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './catalog-strategies.interface';
+export * from './category-facades.interface';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect-angular",
-  "version": "6.0.0-alpha.0",
+  "version": "6.0.0-beta.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
@@ -9,17 +9,31 @@
     "url": "https://github.com/B4AGroup/b4a-firebase-libs"
   },
   "peerDependencies": {
-    "@angular/common": "^15.1.4",
-    "@angular/core": "^15.1.4",
-    "@angular/fire": "7.5.0",
-    "@infrab4a/connect": "6.0.0-alpha.0",
-    "class-transformer": "^0.5.1",
+    "@angular/common": "17.2.3",
+    "@angular/core": "17.2.3",
+    "@angular/fire": "17.0.1",
+    "@infrab4a/connect": "5.3.0-beta.0",
     "js-cookie": "^3.0.1",
-    "rxjs": "^6.6.7",
+    "class-transformer": "^0.5.1",
+    "rxjs": "^7.8.1",
     "ts-custom-error": "^3.3.1"
   },
   "dependencies": {
     "js-cookie": "^3.0.1",
     "tslib": "^2.4.0"
-  }
-}
+  },
+  "module": "fesm2022/infrab4a-connect-angular.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/infrab4a-connect-angular.mjs",
+      "esm": "./esm2022/infrab4a-connect-angular.mjs",
+      "default": "./fesm2022/infrab4a-connect-angular.mjs"
+    }
+  },
+  "sideEffects": false
+}

package/persistence/cookie-data-persistence.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+import { DataPersistence } from './data-persistence';
+import * as i0 from "@angular/core";
+export declare class CookieDataPersistence implements DataPersistence {
+    get(key: string): Observable<string>;
+    remove(key: string): Observable<void>;
+    set(key: string, value: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookieDataPersistence, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CookieDataPersistence>;
+}

package/persistence/data-persistence.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from 'rxjs';
+export interface DataPersistence {
+    get(key: string): Observable<string>;
+    remove(key: string): Observable<void>;
+    set(key: string, value: string): Observable<void>;
+}

package/persistence/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cookie-data-persistence';
+export * from './data-persistence';

package/services/auth.service.d.ts

@@ -0,0 +1,18 @@
+import { Auth, User as FirebaseUser } from '@angular/fire/auth';
+import { User, UserRepository } from '@infrab4a/connect';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class AuthService {
+    private readonly angularFireAuth;
+    private readonly userRepository;
+    constructor(angularFireAuth: Auth, userRepository: UserRepository);
+    getAuthstate(): Observable<{
+        user: User;
+        isAnonymous: boolean;
+    }>;
+    getUser(): Observable<User>;
+    getTokenId(): Observable<string>;
+    getFireUser(): Observable<FirebaseUser>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

package/services/cart/cart-services.facade.d.ts

@@ -0,0 +1,12 @@
+import { HttpClient } from '@angular/common/http';
+import { AuthService } from '../auth.service';
+import { CheckoutService } from '../checkout.service';
+import * as i0 from "@angular/core";
+export declare class CartServicesFacade {
+    readonly authService: AuthService;
+    readonly checkoutService: CheckoutService;
+    readonly httpClient: HttpClient;
+    constructor(authService: AuthService, checkoutService: CheckoutService, httpClient: HttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CartServicesFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CartServicesFacade>;
+}

package/services/cart/index.d.ts

@@ -0,0 +1 @@
+export { CartServicesFacade } from './cart-services.facade';

package/services/cart.service.d.ts

@@ -0,0 +1,26 @@
+import { LineItem, User } from '@infrab4a/connect';
+import { Observable } from 'rxjs';
+import { CartServicesFacade } from './cart';
+import { ConfigurationFacade } from './shared';
+import { RequiredCheckoutData } from './types';
+import * as i0 from "@angular/core";
+export type Cart = {
+    [id: string]: LineItem;
+};
+export declare class CartService {
+    private readonly servicesFacade;
+    private readonly configurationFacade;
+    private cartSubject;
+    private checkoutUrl;
+    constructor(servicesFacade: CartServicesFacade, configurationFacade: ConfigurationFacade);
+    addItem(item: LineItem, quantity?: number): Observable<Cart>;
+    decreaseItem(item: LineItem): Observable<Cart>;
+    removeItem(item: LineItem): Observable<Cart>;
+    updateUserCart(user: User): Observable<Cart>;
+    getCart(checkout?: RequiredCheckoutData): Observable<Cart>;
+    clearCart(): Observable<Cart>;
+    private buildCartFromCheckout;
+    private generateCartObject;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CartService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CartService>;
+}

package/services/catalog/adapters/category-structure.adapter.d.ts

@@ -0,0 +1,4 @@
+import { Category, Product, RepositoryFindFielters } from '@infrab4a/connect/';
+export interface CategoryStructureAdapter {
+    buildProductFilterByCategory(category: Category): Promise<RepositoryFindFielters<Product>>;
+}

package/services/catalog/adapters/index.d.ts

@@ -0,0 +1,3 @@
+export * from './category-structure.adapter';
+export * from './new-category-structure.adapter';
+export * from './old-category-structure.adapter';

package/services/catalog/adapters/new-category-structure.adapter.d.ts

@@ -0,0 +1,12 @@
+import { Category, CategoryRepository, Product, RepositoryFindFielters } from '@infrab4a/connect';
+import { CategoryStructureAdapter } from './category-structure.adapter';
+import * as i0 from "@angular/core";
+export declare class NewCategoryStructureAdapter implements CategoryStructureAdapter {
+    private readonly categoryRepository;
+    constructor(categoryRepository: CategoryRepository);
+    buildProductFilterByCategory(category: Category): Promise<RepositoryFindFielters<Product>>;
+    private getAllCategoriesIdFromCategory;
+    private getCategory;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewCategoryStructureAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NewCategoryStructureAdapter>;
+}

package/services/catalog/adapters/old-category-structure.adapter.d.ts

@@ -0,0 +1,10 @@
+import { Category, CategoryRepository, Product, RepositoryFindFielters } from '@infrab4a/connect';
+import { CategoryStructureAdapter } from './category-structure.adapter';
+import * as i0 from "@angular/core";
+export declare class OldCategoryStructureAdapter implements CategoryStructureAdapter {
+    private readonly categoryRepository;
+    constructor(categoryRepository: CategoryRepository);
+    buildProductFilterByCategory(category: Category): Promise<RepositoryFindFielters<Product>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OldCategoryStructureAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OldCategoryStructureAdapter>;
+}

package/services/catalog/catalog.service.d.ts

@@ -0,0 +1,24 @@
+import { Category, RepositoryCacheOptions, Shops } from '@infrab4a/connect';
+import { CatalogSearchContext } from './context/catalog-search.context';
+import { CatalogHelpersService } from './services';
+import { FetchProductsParams, FetchProductsResponse, StockNotificationParams } from './types';
+import * as i0 from "@angular/core";
+export declare class CatalogService<T extends Category = Category> {
+    private readonly searchContext;
+    private readonly helpersService;
+    private readonly shop;
+    constructor(searchContext: CatalogSearchContext, helpersService: CatalogHelpersService, shop: Shops);
+    fetchProducts(options: FetchProductsParams<T>, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<FetchProductsResponse>;
+    addCustomerToStockNotification(params: StockNotificationParams): Promise<void>;
+    private validateRequest;
+    private buildSearchParams;
+    private buildResponse;
+    private buildLimitQuery;
+    private hasProfile;
+    private hasTerm;
+    private hasCategory;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogService<any>>;
+}

package/services/catalog/category.service.d.ts

@@ -0,0 +1,22 @@
+import { Category, Filter, ProductGender, RepositoryCacheOptions, Shops } from '@infrab4a/connect';
+import { CategoryRepositoryFacade, ProductCatalogFacade } from './facades';
+import * as i0 from "@angular/core";
+type FetchBrandsOptions = {
+    mainGender?: ProductGender;
+    shop?: Shops;
+};
+export declare class CategoryService {
+    private readonly categoryFacade;
+    private readonly productCatalog;
+    private readonly shop;
+    constructor(categoryFacade: CategoryRepositoryFacade, productCatalog: ProductCatalogFacade, shop: Shops);
+    fetchBrands(category: Category, options?: FetchBrandsOptions, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category[]>;
+    fetchFilterOptions(category: Category, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Filter[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CategoryService>;
+}
+export {};

package/services/catalog/context/catalog-search.context.d.ts

@@ -0,0 +1,14 @@
+import { Product, RepositoryCacheOptions, RepositoryFindResult, Shops } from '@infrab4a/connect';
+import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces';
+export declare class CatalogSearchContext {
+    private readonly categoryStrategy;
+    private readonly termStrategy;
+    private readonly profileStrategy;
+    private strategies;
+    constructor(categoryStrategy: CatalogSearchStrategy, termStrategy: CatalogSearchStrategy, profileStrategy: CatalogSearchStrategy);
+    executeSearch(params: CatalogSearchParams, shop: Shops, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<RepositoryFindResult<Product>>;
+    private initializeStrategies;
+    private selectStrategy;
+}

package/services/catalog/enums/index.d.ts

@@ -0,0 +1 @@
+export * from './product-sorts.enum';

package/services/catalog/enums/product-sorts.enum.d.ts

@@ -0,0 +1,9 @@
+export declare enum ProductSorts {
+    MOST_RELEVANT = "most-relevant",
+    BEST_SELLER = "best-sellers",
+    BIGGEST_PRICE = "biggest-price",
+    LOWEST_PRICE = "lowest-price",
+    BIGGEST_DISCOUNT = "biggest-discount",
+    BEST_RATING = "best-rating",
+    NEWS = "news"
+}

package/services/catalog/facades/catalog-service.facade.d.ts

@@ -0,0 +1,15 @@
+import { Shops } from '@infrab4a/connect';
+import { CatalogService } from '../catalog.service';
+import { CatalogHelpersService } from '../services';
+import { CatalogStrategiesFacade } from './catalog-strategies.facade';
+import * as i0 from "@angular/core";
+export declare class CatalogServiceFacade {
+    private readonly helpersService;
+    private readonly strategiesFacade;
+    private readonly shop;
+    private catalogService;
+    constructor(helpersService: CatalogHelpersService, strategiesFacade: CatalogStrategiesFacade, shop: Shops);
+    getCatalogService(): CatalogService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogServiceFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogServiceFacade>;
+}

package/services/catalog/facades/catalog-strategies.facade.d.ts

@@ -0,0 +1,10 @@
+import { CategorySearchStrategy, ProfileSearchStrategy, TermSearchStrategy } from '../strategies';
+import * as i0 from "@angular/core";
+export declare class CatalogStrategiesFacade {
+    readonly categoryStrategy: CategorySearchStrategy;
+    readonly termStrategy: TermSearchStrategy;
+    readonly profileStrategy: ProfileSearchStrategy;
+    constructor(categoryStrategy: CategorySearchStrategy, termStrategy: TermSearchStrategy, profileStrategy: ProfileSearchStrategy);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStrategiesFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogStrategiesFacade>;
+}

package/services/catalog/facades/category-repository.facade.d.ts

@@ -0,0 +1,9 @@
+import { CategoryFilterRepository, CategoryRepository } from '@infrab4a/connect';
+import * as i0 from "@angular/core";
+export declare class CategoryRepositoryFacade {
+    readonly categoryRepository: CategoryRepository;
+    readonly categoryFilterRepository: CategoryFilterRepository;
+    constructor(categoryRepository: CategoryRepository, categoryFilterRepository: CategoryFilterRepository);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CategoryRepositoryFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CategoryRepositoryFacade>;
+}

package/services/catalog/facades/category-service.facade.d.ts

@@ -0,0 +1,15 @@
+import { Shops } from '@infrab4a/connect';
+import { CategoryService } from '../category.service';
+import { CategoryRepositoryFacade } from './category-repository.facade';
+import { ProductCatalogFacade } from './product-catalog.facade';
+import * as i0 from "@angular/core";
+export declare class CategoryServiceFacade {
+    private readonly categoryRepositoryFacade;
+    private readonly productCatalogFacade;
+    private readonly shop;
+    private categoryService;
+    constructor(categoryRepositoryFacade: CategoryRepositoryFacade, productCatalogFacade: ProductCatalogFacade, shop: Shops);
+    getCategoryService(): CategoryService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CategoryServiceFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CategoryServiceFacade>;
+}

package/{src/services/catalog/facades/index.ts → services/catalog/facades/index.d.ts}

@@ -1,5 +1,5 @@
-export { CatalogServiceFacade } from './catalog-service.facade'
-export { CatalogStrategiesFacade } from './catalog-strategies.facade'
-export { CategoryRepositoryFacade } from './category-repository.facade'
-export { CategoryServiceFacade } from './category-service.facade'
-export { ProductCatalogFacade } from './product-catalog.facade'
+export { CatalogServiceFacade } from './catalog-service.facade';
+export { CatalogStrategiesFacade } from './catalog-strategies.facade';
+export { CategoryRepositoryFacade } from './category-repository.facade';
+export { CategoryServiceFacade } from './category-service.facade';
+export { ProductCatalogFacade } from './product-catalog.facade';

package/services/catalog/facades/product-catalog.facade.d.ts

@@ -0,0 +1,10 @@
+import { ProductRepository } from '@infrab4a/connect';
+import { CategoryStructureAdapter } from '../adapters';
+import * as i0 from "@angular/core";
+export declare class ProductCatalogFacade {
+    readonly productRepository: ProductRepository;
+    readonly categoryStructureAdapter: CategoryStructureAdapter;
+    constructor(productRepository: ProductRepository, categoryStructureAdapter: CategoryStructureAdapter);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductCatalogFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductCatalogFacade>;
+}

package/services/catalog/helpers/brand-manager.helper.d.ts

@@ -0,0 +1,14 @@
+import { CatalogSearchParams } from '../../../interfaces';
+import { ProductCatalogFacade } from '../facades';
+import * as i0 from "@angular/core";
+export declare class BrandManagerHelper {
+    private readonly productCatalog;
+    private brandsList;
+    constructor(productCatalog: ProductCatalogFacade);
+    setBrandsList(options: CatalogSearchParams, brands: string[]): Promise<void>;
+    getBrandsList(indexKey: string): string[];
+    buildIndexBrands(options: CatalogSearchParams): string;
+    private fetchBrandsOnly;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrandManagerHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BrandManagerHelper>;
+}

package/services/catalog/helpers/catalog-filter.helper.d.ts

@@ -0,0 +1,8 @@
+import { Product, RepositoryFindFielters } from '@infrab4a/connect';
+import { CatalogFilters } from '../../../interfaces';
+import * as i0 from "@angular/core";
+export declare class CatalogFilterHelper {
+    buildFilterQuery(filters: CatalogFilters): RepositoryFindFielters<Product>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogFilterHelper>;
+}

package/services/catalog/helpers/catalog-sort.helper.d.ts

@@ -0,0 +1,7 @@
+import { Product, RepositoryOrderBy } from '@infrab4a/connect';
+import * as i0 from "@angular/core";
+export declare class CatalogSortHelper {
+    buildSortQuery(sort: string): RepositoryOrderBy<Product>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSortHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogSortHelper>;
+}

package/services/catalog/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './brand-manager.helper';
+export * from './catalog-filter.helper';
+export * from './catalog-sort.helper';
+export * from './product-fields.helper';

package/services/catalog/helpers/product-fields.helper.d.ts

@@ -0,0 +1,7 @@
+import { NonFunctionPropertyNames, Product } from '@infrab4a/connect';
+import * as i0 from "@angular/core";
+export declare class ProductFieldsHelper {
+    getStandardFields(): NonFunctionPropertyNames<Product>[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductFieldsHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductFieldsHelper>;
+}

package/services/catalog/index.d.ts

@@ -0,0 +1,7 @@
+export * from './adapters';
+export * from './catalog.service';
+export * from './category.service';
+export * from './enums';
+export * from './models';
+export * from './types';
+export * from './wishlist.service';

package/services/catalog/models/category-with-tree.model.d.ts

@@ -0,0 +1,4 @@
+import { Category } from '@infrab4a/connect';
+export declare class CategoryWithTree extends Category {
+    children?: CategoryWithTree[];
+}

package/services/catalog/models/index.d.ts

@@ -0,0 +1 @@
+export * from './category-with-tree.model';

package/services/catalog/services/catalog-helpers.service.d.ts

@@ -0,0 +1,17 @@
+import { ProductServicesFacade } from '../../../interfaces';
+import { BrandManagerHelper, CatalogFilterHelper, CatalogSortHelper, ProductFieldsHelper } from '../helpers';
+import { CatalogOperationsFacade } from './catalog-operations.facade';
+import { ProductManagementFacade } from './product-management.facade';
+import * as i0 from "@angular/core";
+export declare class CatalogHelpersService {
+    private readonly catalogOperations;
+    private readonly productManagement;
+    constructor(catalogOperations: CatalogOperationsFacade, productManagement: ProductManagementFacade);
+    getFilterHelper(): CatalogFilterHelper;
+    getSortHelper(): CatalogSortHelper;
+    getFieldsHelper(): ProductFieldsHelper;
+    getBrandManager(): BrandManagerHelper;
+    getProductServices(): ProductServicesFacade;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogHelpersService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogHelpersService>;
+}

package/services/catalog/services/catalog-operations.facade.d.ts

@@ -0,0 +1,13 @@
+import { CatalogFilterHelper, CatalogSortHelper, ProductFieldsHelper } from '../helpers';
+import * as i0 from "@angular/core";
+export declare class CatalogOperationsFacade {
+    private readonly filterHelper;
+    private readonly sortHelper;
+    private readonly fieldsHelper;
+    constructor(filterHelper: CatalogFilterHelper, sortHelper: CatalogSortHelper, fieldsHelper: ProductFieldsHelper);
+    getFilterHelper(): CatalogFilterHelper;
+    getSortHelper(): CatalogSortHelper;
+    getFieldsHelper(): ProductFieldsHelper;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogOperationsFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogOperationsFacade>;
+}

package/services/catalog/services/catalog-repository.service.d.ts

@@ -0,0 +1,12 @@
+import { ProductServicesFacade } from '../../../interfaces';
+import { ProductCatalogFacade } from '../facades';
+import * as i0 from "@angular/core";
+export declare class CatalogRepositoryService {
+    private readonly productCatalog;
+    private readonly productServices;
+    constructor(productCatalog: ProductCatalogFacade, productServices: ProductServicesFacade);
+    getProductCatalog(): ProductCatalogFacade;
+    getProductServices(): ProductServicesFacade;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogRepositoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogRepositoryService>;
+}

package/{src/services/catalog/services/index.ts → services/catalog/services/index.d.ts}

@@ -1,4 +1,4 @@
-export { CatalogHelpersService } from './catalog-helpers.service'
-export { CatalogOperationsFacade } from './catalog-operations.facade'
-export * from './catalog-repository.service'
-export { ProductManagementFacade } from './product-management.facade'
+export { CatalogHelpersService } from './catalog-helpers.service';
+export { CatalogOperationsFacade } from './catalog-operations.facade';
+export * from './catalog-repository.service';
+export { ProductManagementFacade } from './product-management.facade';

package/services/catalog/services/product-management.facade.d.ts

@@ -0,0 +1,12 @@
+import { ProductServicesFacade } from '../../../interfaces';
+import { BrandManagerHelper } from '../helpers';
+import * as i0 from "@angular/core";
+export declare class ProductManagementFacade {
+    private readonly brandManager;
+    private readonly productServices;
+    constructor(brandManager: BrandManagerHelper, productServices: ProductServicesFacade);
+    getBrandManager(): BrandManagerHelper;
+    getProductServices(): ProductServicesFacade;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductManagementFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductManagementFacade>;
+}

package/services/catalog/strategies/category-search.strategy.d.ts

@@ -0,0 +1,19 @@
+import { Product, RepositoryCacheOptions, RepositoryFindResult, Shops } from '@infrab4a/connect';
+import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces';
+import { CatalogHelpersService, CatalogRepositoryService } from '../services';
+import * as i0 from "@angular/core";
+export declare class CategorySearchStrategy implements CatalogSearchStrategy {
+    private readonly repositoryService;
+    private readonly helpersService;
+    constructor(repositoryService: CatalogRepositoryService, helpersService: CatalogHelpersService);
+    search(params: CatalogSearchParams, shop: Shops, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<RepositoryFindResult<Product>>;
+    private searchWithMostRelevant;
+    private searchDefault;
+    private getProductIds;
+    private findAndSortByMostRelevant;
+    private sortProductsByRelevance;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CategorySearchStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CategorySearchStrategy>;
+}

package/services/catalog/strategies/index.d.ts

@@ -0,0 +1,3 @@
+export * from './category-search.strategy';
+export * from './profile-search.strategy';
+export * from './term-search.strategy';

package/services/catalog/strategies/profile-search.strategy.d.ts

@@ -0,0 +1,14 @@
+import { Product, RepositoryCacheOptions, RepositoryFindResult, Shops } from '@infrab4a/connect';
+import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces';
+import { CatalogHelpersService, CatalogRepositoryService } from '../services';
+import * as i0 from "@angular/core";
+export declare class ProfileSearchStrategy implements CatalogSearchStrategy {
+    private readonly repositoryService;
+    private readonly helpersService;
+    constructor(repositoryService: CatalogRepositoryService, helpersService: CatalogHelpersService);
+    search(params: CatalogSearchParams, shop: Shops, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<RepositoryFindResult<Product>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileSearchStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProfileSearchStrategy>;
+}

package/services/catalog/strategies/term-search.strategy.d.ts

@@ -0,0 +1,20 @@
+import { Product, RepositoryCacheOptions, RepositoryFindResult, Shops } from '@infrab4a/connect';
+import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces';
+import { CatalogHelpersService, CatalogRepositoryService } from '../services';
+import * as i0 from "@angular/core";
+export declare class TermSearchStrategy implements CatalogSearchStrategy {
+    private readonly repositoryService;
+    private readonly helpersService;
+    private productsByTerm;
+    constructor(repositoryService: CatalogRepositoryService, helpersService: CatalogHelpersService);
+    search(params: CatalogSearchParams, shop: Shops, _optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<RepositoryFindResult<Product>>;
+    private searchWithMostRelevant;
+    private searchDefault;
+    private sortByTermRelevance;
+    private getDetailedProducts;
+    private findCatalogIdsBySearch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TermSearchStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TermSearchStrategy>;
+}