@infrab4a/connect-angular 5.5.0-alpha.1 → 5.5.0-alpha.2

package/index.d.ts

@@ -1,6 +1,755 @@
-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';
+import * as i0 from '@angular/core';
+import { ModuleWithProviders, Type } from '@angular/core';
+import { FirebaseOptions } from '@angular/fire/app';
+import { AppCheckOptions } from '@angular/fire/app-check';
+import * as _infrab4a_connect from '@infrab4a/connect';
+import { HasuraGraphQLAuthOptions, CacheConfig, AxiosElasticSearchConfig, VertexSearchConfig, FirestoreConstructorParams, Shops, UserRepository, User, Checkout, CheckoutSubscription, CheckoutRepository, CheckoutTypes, Coupon, CheckoutStockValidation, UserAddress, ShippingProductRequest, ShippingMethodResponse, CheckoutPayloadRequest, CheckoutResponse, LineItem, CategoryRepository, Category as Category$1, RepositoryFindFielters as RepositoryFindFielters$1, Product as Product$1, ProductGender, RepositoryCacheOptions, RepositoryFindResult, ProductStockNotificationRepository, ProductSearchIndex, CategoryFilterRepository, Filter, ProductRepository, RepositoryOrderBy, NonFunctionPropertyNames, WishlistRepository, LogRepository, PersonType, Wishlist, CouponRepository, OrderRepository, CheckoutSubscriptionRepository, HomeRepository, Home, Banner, OrderFirestoreRepository, ProductReviewRepository, VariantRepository, ProductReview, Order } from '@infrab4a/connect';
+import { Observable, Subject } from 'rxjs';
+import { Auth, User as User$1 } from '@angular/fire/auth';
+import { HttpClient } from '@angular/common/http';
+import { Category, RepositoryFindFielters, Product } from '@infrab4a/connect/';
+import { Shops as Shops$1 } from '@infrab4a/connect/src';
+import { Firestore } from '@angular/fire/firestore';
+
+type HasuraGraphQLOptions = {
+    endpoint: string;
+    credentials?: HasuraGraphQLAuthOptions;
+    cache?: CacheConfig;
+};
+declare class AngularHasuraGraphQLModule {
+    static initializeApp(options: HasuraGraphQLOptions): ModuleWithProviders<AngularHasuraGraphQLModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularHasuraGraphQLModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularHasuraGraphQLModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AngularHasuraGraphQLModule>;
+}
+
+interface DataPersistence {
+    get(key: string): Observable<string>;
+    remove(key: string): Observable<void>;
+    set(key: string, value: string): Observable<void>;
+}
+
+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>;
+}
+
+type FirebaseAppConfig = Record<string, any>;
+
+declare class AngularElasticSeachModule {
+    static initializeApp(options: AxiosElasticSearchConfig): ModuleWithProviders<AngularElasticSeachModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularElasticSeachModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularElasticSeachModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AngularElasticSeachModule>;
+}
+
+declare class AngularVertexSeachModule {
+    static initializeApp(options: VertexSearchConfig): ModuleWithProviders<AngularVertexSeachModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularVertexSeachModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularVertexSeachModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AngularVertexSeachModule>;
+}
+
+declare class AngularFirebaseAuthModule {
+    static initializeApp(options: FirebaseOptions, nameOrConfig?: string | FirebaseAppConfig): ModuleWithProviders<AngularFirebaseAuthModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFirebaseAuthModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFirebaseAuthModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AngularFirebaseAuthModule>;
+}
+
+type FirestoreOptions = Pick<FirestoreConstructorParams<any>, 'firestore' | 'interceptors'>;
+declare class AngularFirestoreModule {
+    static initializeApp(options: {
+        firebase: FirebaseOptions;
+        elasticSearch: AxiosElasticSearchConfig;
+    }, nameOrConfig?: string | FirebaseAppConfig): ModuleWithProviders<AngularFirestoreModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFirestoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFirestoreModule, never, [typeof AngularElasticSeachModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AngularFirestoreModule>;
+}
+
+declare class AngularConnectModule {
+    static initializeApp(defaultShop: Shops, options: {
+        firebase?: FirebaseOptions;
+        elasticSearch?: AxiosElasticSearchConfig;
+        vertexConfig?: VertexSearchConfig;
+        hasura: HasuraGraphQLOptions;
+        backendUrl: string;
+        oldCategoryStructure?: boolean;
+        storageBaseUrl?: string;
+        persistenceProvider?: Type<DataPersistence>;
+        appCheckProvider?: AppCheckOptions['provider'];
+    }, nameOrConfig?: string | FirebaseAppConfig): ModuleWithProviders<AngularConnectModule>;
+    private static buildCoreProviders;
+    private static buildConditionalProviders;
+    private static selectCategoryStructureAdapter;
+    private static createProviderIfExists;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularConnectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularConnectModule, never, [typeof AngularElasticSeachModule, typeof AngularVertexSeachModule, typeof AngularFirebaseAuthModule, typeof AngularFirestoreModule, typeof AngularHasuraGraphQLModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AngularConnectModule>;
+}
+
+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<User$1>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+
+type PendingProductReview = {
+    id: string;
+    isEdition: boolean;
+    orderId: string;
+    orderNumber: string;
+    name: string;
+    image: string;
+    deliveryDate: string;
+    evaluationInAnalysis: boolean;
+    rating?: number;
+    shopProductSlug: string;
+};
+
+type ProductReviewCreate = {
+    productId: string;
+    shop: Shops$1;
+    rate: number;
+    author: string;
+    email: string;
+    location: string;
+    comment: string;
+    title: string;
+    personId: number;
+    points: number;
+    orderId: string;
+};
+
+type RequiredCheckoutData = Partial<Pick<Checkout, 'id' | 'user' | 'shop' | 'lineItems'>>;
+
+type RequiredCheckoutSubscriptionData = Partial<Pick<CheckoutSubscription, 'id'>>;
+
+declare class CheckoutRepositoriesFacade {
+    readonly checkoutRepository: CheckoutRepository;
+    readonly userRepository: UserRepository;
+    constructor(checkoutRepository: CheckoutRepository, userRepository: UserRepository);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckoutRepositoriesFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckoutRepositoriesFacade>;
+}
+
+declare class CheckoutDependenciesFacade {
+    readonly dataPersistence: DataPersistence;
+    readonly httpClient: HttpClient;
+    constructor(dataPersistence: DataPersistence, httpClient: HttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckoutDependenciesFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckoutDependenciesFacade>;
+}
+
+declare class ConfigurationFacade {
+    readonly defaultShop: Shops;
+    readonly firebaseOptions: FirebaseOptions;
+    constructor(defaultShop: Shops, firebaseOptions: FirebaseOptions);
+    getCheckoutUrl(): string;
+    getProjectId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationFacade>;
+}
+
+declare class CheckoutService {
+    private readonly repositoriesFacade;
+    private readonly dependenciesFacade;
+    private readonly configurationFacade;
+    private checkoutUrl;
+    constructor(repositoriesFacade: CheckoutRepositoriesFacade, dependenciesFacade: CheckoutDependenciesFacade, configurationFacade: ConfigurationFacade);
+    getCheckout(checkoutData?: RequiredCheckoutData): Observable<Checkout>;
+    getUserByCheckout(checkoutId: string): Observable<User>;
+    updateCheckoutLineItems(checkout: Partial<Checkout>): Observable<Checkout>;
+    updateCheckoutUser(checkout: Partial<Checkout>): Observable<Checkout>;
+    clearCheckoutFromSession(): Observable<void>;
+    resetCheckoutValues(): Observable<Checkout>;
+    applyCouponDiscount(nickname: string, checkoutType: CheckoutTypes): Observable<Coupon>;
+    removeCouponDiscount(): Observable<Checkout>;
+    validateStockProducts(): Observable<CheckoutStockValidation>;
+    selectShippingAddress(address: UserAddress): Observable<Checkout>;
+    getAvailableShippingForProduct(productShipping: ShippingProductRequest): Observable<ShippingMethodResponse[]>;
+    getAvailableShippingForCheckout(): Observable<ShippingMethodResponse[]>;
+    selectShipping(option: string): Observable<Checkout>;
+    createOrder(checkoutPayload: CheckoutPayloadRequest, paymentProvider: string, applicationVersion: string): Observable<CheckoutResponse>;
+    private createCheckout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckoutService>;
+}
+
+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>;
+}
+
+type Cart = {
+    [id: string]: LineItem;
+};
+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>;
+}
+
+interface CategoryStructureAdapter {
+    buildProductFilterByCategory(category: Category): Promise<RepositoryFindFielters<Product>>;
+}
+
+declare class NewCategoryStructureAdapter implements CategoryStructureAdapter {
+    private readonly categoryRepository;
+    constructor(categoryRepository: CategoryRepository);
+    buildProductFilterByCategory(category: Category$1): Promise<RepositoryFindFielters$1<Product$1>>;
+    private getAllCategoriesIdFromCategory;
+    private getCategory;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewCategoryStructureAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NewCategoryStructureAdapter>;
+}
+
+declare class OldCategoryStructureAdapter implements CategoryStructureAdapter {
+    private readonly categoryRepository;
+    constructor(categoryRepository: CategoryRepository);
+    buildProductFilterByCategory(category: Category$1): Promise<RepositoryFindFielters$1<Product$1>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OldCategoryStructureAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OldCategoryStructureAdapter>;
+}
+
+interface CatalogSearchParams {
+    category?: Category$1;
+    profile?: string[];
+    term?: string;
+    filters?: CatalogFilters;
+    mainGender?: ProductGender;
+    limits: {
+        limit?: number;
+        offset?: number;
+    };
+    sort?: string;
+}
+interface CatalogFilters {
+    clubDiscount?: number[];
+    brands?: string[];
+    prices?: {
+        min?: number;
+        max?: number;
+        subscriberPrice?: boolean;
+    };
+    gender?: ProductGender[];
+    rate?: number;
+    customOptions?: string[];
+    tags?: string[];
+}
+interface CatalogSearchStrategy {
+    search(params: CatalogSearchParams, shop: Shops, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<RepositoryFindResult<Product$1>>;
+}
+
+interface ProductServicesFacade {
+    productStockNotificationRepository: ProductStockNotificationRepository;
+    categoryRepository: CategoryRepository;
+    productSearch: ProductSearchIndex;
+}
+
+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$1>>;
+    private initializeStrategies;
+    private selectStrategy;
+}
+
+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$1>>;
+    private searchWithMostRelevant;
+    private searchDefault;
+    private getProductIds;
+    private findAndSortByMostRelevant;
+    private sortProductsByRelevance;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CategorySearchStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CategorySearchStrategy>;
+}
+
+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$1>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileSearchStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProfileSearchStrategy>;
+}
+
+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$1>>;
+    private searchWithMostRelevant;
+    private searchDefault;
+    private sortByTermRelevance;
+    private getDetailedProducts;
+    private findCatalogIdsBySearch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TermSearchStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TermSearchStrategy>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+type FetchBrandsOptions = {
+    mainGender?: ProductGender;
+    shop?: Shops;
+};
+declare class CategoryService {
+    private readonly categoryFacade;
+    private readonly productCatalog;
+    private readonly shop;
+    constructor(categoryFacade: CategoryRepositoryFacade, productCatalog: ProductCatalogFacade, shop: Shops);
+    fetchBrands(category: Category$1, options?: FetchBrandsOptions, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category$1[]>;
+    getMenuBrands(): Promise<Category$1[]>;
+    fetchFilterOptions(category: Category$1, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Filter[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CategoryService>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+declare class CatalogFilterHelper {
+    buildFilterQuery(filters: CatalogFilters): RepositoryFindFielters$1<Product$1>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogFilterHelper>;
+}
+
+declare class CatalogSortHelper {
+    buildSortQuery(sort: string): RepositoryOrderBy<Product$1>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSortHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogSortHelper>;
+}
+
+declare class ProductFieldsHelper {
+    getStandardFields(): NonFunctionPropertyNames<Product$1>[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductFieldsHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductFieldsHelper>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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"
+}
+
+type ProductSort = `${ProductSorts}`;
+
+type FetchProductsOptions = {
+    page?: number;
+    perPage?: number;
+    sort?: ProductSort;
+    mainGender?: ProductGender;
+};
+
+type FetchProductsMainParams<T extends Category$1> = {
+    category?: T;
+    profile?: string[];
+    term?: string;
+};
+type FetchProductsParams<T extends Category$1> = FetchProductsOptions & ({
+    category: FetchProductsMainParams<T>['category'];
+    filters?: CatalogFilters & {
+        customOptions?: never;
+    };
+} | {
+    profile: FetchProductsMainParams<T>['profile'];
+    filters?: CatalogFilters & {
+        customOptions?: never;
+        tags?: never;
+    };
+} | {
+    term: FetchProductsMainParams<T>['term'];
+    filters?: CatalogFilters & {
+        customOptions?: never;
+    };
+});
+
+type FetchProductsResponse = {
+    products: {
+        data: Product$1[];
+        total: number;
+    };
+    pages: number;
+    prices: {
+        price: {
+            min: number;
+            max: number;
+        };
+        subscriberPrice: {
+            min: number;
+            max: number;
+        };
+    };
+    brands?: string[];
+};
+
+type StockNotificationParams = {
+    shop: Shops;
+    productId: string;
+    name: string;
+    email: string;
+};
+type BuildResponseParams<T extends Category$1 = Category$1> = {
+    data: Product$1[];
+    total: number;
+    maximum: any;
+    minimal: any;
+    searchParams: CatalogSearchParams;
+    options: FetchProductsParams<T>;
+};
+
+declare class CatalogService<T extends Category$1 = Category$1> {
+    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>>;
+}
+
+declare class CategoryWithTree extends Category$1 {
+    children?: CategoryWithTree[];
+}
+
+declare class WishlistService {
+    private readonly wishlistRepository;
+    private readonly productRepository;
+    private readonly logRepository;
+    private readonly shop;
+    private catalogService;
+    private categoryService;
+    constructor(wishlistRepository: WishlistRepository, productRepository: ProductRepository, logRepository: LogRepository, shop: Shops);
+    initializeServices(catalogServiceFacade: CatalogServiceFacade, categoryServiceFacade: CategoryServiceFacade): void;
+    getCatalogService(): CatalogService<_infrab4a_connect.Category>;
+    getCategoryService(): CategoryService;
+    create({ personId, title, description, published, userFullName, userPhoto, theme, bannerUrl, personType, personIsSubscriber, }: {
+        personId: string;
+        title: string;
+        description: string;
+        published: boolean;
+        userFullName: string;
+        userPhoto?: string;
+        theme?: string;
+        bannerUrl?: string;
+        personType?: PersonType;
+        personIsSubscriber?: boolean;
+    }): Promise<Wishlist>;
+    private buildWishlistData;
+    private findExistingWishlistByPersonId;
+    private createNewWishlist;
+    update({ id, title, description, published, userFullName, userPhoto, theme, bannerUrl, personType, personIsSubscriber, }: {
+        id: string;
+        title: string;
+        description: string;
+        published: boolean;
+        userFullName: string;
+        userPhoto?: string;
+        theme?: string;
+        bannerUrl?: string;
+        personType?: PersonType;
+        personIsSubscriber?: boolean;
+    }): Promise<Wishlist>;
+    delete(wishlistId: string): Promise<void>;
+    getWishlistBySlug(slug: string): Promise<Wishlist>;
+    getWishlistsByPerson(personId: string): Promise<Wishlist[]>;
+    addProduct(wishlistId: string, productId: string): Promise<Wishlist>;
+    removeProduct(wishlistId: string, productId: string): Promise<Wishlist>;
+    private findById;
+    private findProductById;
+    private createWishlistLog;
+    private createWishlistOperationLog;
+    private createWishlistProductLog;
+    private getOperationTypeFromWishlistLogType;
+    private buildWishlistLogDocument;
+    private buildProductLogData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WishlistService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WishlistService>;
+}
+
+declare class CouponRepositoriesFacade {
+    readonly couponRepository: CouponRepository;
+    readonly orderRepository: OrderRepository;
+    readonly categoryRepository: CategoryRepository;
+    constructor(couponRepository: CouponRepository, orderRepository: OrderRepository, categoryRepository: CategoryRepository);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CouponRepositoriesFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CouponRepositoriesFacade>;
+}
+
+type CheckCouponParams = {
+    nickname: string;
+    checkoutType: CheckoutTypes;
+    checkout: Partial<Checkout>;
+    plan: string;
+};
+
+declare class CouponService {
+    private readonly repositoriesFacade;
+    private readonly configurationFacade;
+    constructor(repositoriesFacade: CouponRepositoriesFacade, configurationFacade: ConfigurationFacade);
+    checkCoupon(params: CheckCouponParams): Observable<Coupon>;
+    private couponValidation;
+    private couponRulesValidation;
+    private validateSubscriptionCoupon;
+    private validateEcommerceCoupon;
+    private validateUserEligibility;
+    private validateUsageLimits;
+    private validateFirstOrderLimit;
+    private validateCouponUsageLimits;
+    private validateProductEligibility;
+    private throwMinSubTotalError;
+    calcDiscountSubscription(coupon: Coupon, checkout: Partial<CheckoutSubscription>): Observable<number>;
+    private hasMinSubTotal;
+    private hasProductCategories;
+    private coupomUserValidation;
+    private getCouponCategoriesId;
+    private emailIsFromCollaborator;
+    private getLineItensEligebleForDiscount;
+    private calcCheckoutSubtotal;
+    private getOrdersWithCoupon;
+    private getOrdersFromUser;
+    private countOrdersWithUser;
+    private getCouponUseLimits;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CouponService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CouponService>;
+}
+
+declare class CheckoutSubscriptionService {
+    private readonly checkoutSubscriptionRepository;
+    private readonly dataPersistence;
+    private readonly couponService;
+    constructor(checkoutSubscriptionRepository: CheckoutSubscriptionRepository, dataPersistence: DataPersistence, couponService: CouponService);
+    getCheckoutSubscription(checkoutData?: RequiredCheckoutSubscriptionData): Observable<CheckoutSubscription>;
+    clearCheckoutSubscriptionFromSession(): Observable<void>;
+    checkCoupon(nickname: string, _userEmail: string): Observable<Coupon>;
+    calcDiscountSubscription(coupon: Coupon): Observable<number>;
+    private createCheckoutSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckoutSubscriptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CheckoutSubscriptionService>;
+}
+
+declare class UtilHelper {
+    static createSlug(name: string): string;
+}
+
+declare class HomeShopRepositoriesFacade {
+    readonly categoryRepository: CategoryRepository;
+    readonly homeRepository: HomeRepository;
+    readonly productRepository: ProductRepository;
+    constructor(categoryRepository: CategoryRepository, homeRepository: HomeRepository, productRepository: ProductRepository);
+    static ɵfac: i0.ɵɵFactoryDeclaration<HomeShopRepositoriesFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HomeShopRepositoriesFacade>;
+}
+
+type BannerType = 'brand' | 'buyToWin' | 'block' | 'blog';
+declare class HomeShopService {
+    private readonly repositoriesFacade;
+    private readonly configurationFacade;
+    private homeConfiguration;
+    private get homeId();
+    constructor(repositoriesFacade: HomeShopRepositoriesFacade, configurationFacade: ConfigurationFacade);
+    getHomeData(): Observable<Home>;
+    getBanners(type: BannerType): Observable<Banner[]>;
+    getMinValueForFreeShipping(): Observable<number>;
+    private getDiscoverProducts;
+    private getFeaturedProducts;
+    private getVerticalProducts;
+    private getHomeConfiguration;
+    private saveHomeData;
+    private buildCategoryGroupWithRequiredData;
+    private get gender();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HomeShopService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HomeShopService>;
+}
+
+declare class OrderProductReviewService {
+    private readonly orderRepository;
+    private readonly productReviewRepository;
+    private readonly variantRepository;
+    constructor(orderRepository: OrderFirestoreRepository, productReviewRepository: ProductReviewRepository, variantRepository: VariantRepository);
+    getPendingReviewsByEmail(email: string): Promise<PendingProductReview[]>;
+    private getOrdersByEmail;
+    private getProductReview;
+    private buildProductReview;
+    createReview(review: ProductReviewCreate): Promise<ProductReview>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrderProductReviewService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OrderProductReviewService>;
+}
+
+declare class OrderService {
+    private readonly angularFirestore;
+    private readonly orderRepository;
+    orderSubject: Subject<Order>;
+    constructor(angularFirestore: Firestore, orderRepository: OrderFirestoreRepository);
+    getOrder(id: string): Subject<Order>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OrderService>;
+}
+
+export { AngularConnectModule, AngularFirebaseAuthModule, AngularFirestoreModule, AngularHasuraGraphQLModule, AuthService, CartService, CatalogService, CategoryService, CategoryWithTree, CheckoutService, CheckoutSubscriptionService, CookieDataPersistence, CouponService, HomeShopService, NewCategoryStructureAdapter, OldCategoryStructureAdapter, OrderProductReviewService, OrderService, ProductSorts, UtilHelper, WishlistService };
+export type { BuildResponseParams, Cart, CategoryStructureAdapter, DataPersistence, FetchProductsMainParams, FetchProductsOptions, FetchProductsParams, FetchProductsResponse, FirestoreOptions, HasuraGraphQLOptions, ProductSort, StockNotificationParams };