@infrab4a/connect-angular 5.1.0 → 5.2.0

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

@@ -1,7 +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';
+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

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

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

@@ -1 +1 @@
-export * from './category-with-tree.model';
+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/services/catalog/services/index.d.ts

@@ -0,0 +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';

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>;
+}

package/services/catalog/strategies/types/strategy-params.type.d.ts

@@ -0,0 +1,58 @@
+import { RepositoryCacheOptions, Shops } from '@infrab4a/connect';
+export type SearchWithMostRelevantParams = {
+    category: any;
+    filters: any;
+    limits: any;
+    shop: Shops;
+    mainGender: any;
+    optionsCache: {
+        cache?: RepositoryCacheOptions;
+    } | undefined;
+    fields: any;
+};
+export type SearchDefaultParams = {
+    category: any;
+    filters: any;
+    limits: any;
+    shop: Shops;
+    mainGender: any;
+    sort: any;
+    optionsCache: {
+        cache?: RepositoryCacheOptions;
+    } | undefined;
+    fields: any;
+};
+export type FindAndSortByMostRelevantParams = {
+    mostRelevants: string[];
+    productIds: string[];
+    filters: any;
+    limits: any;
+    shop: Shops;
+    mainGender: any;
+    optionsCache: {
+        cache?: RepositoryCacheOptions;
+    } | undefined;
+    fields: any;
+};
+export type TermSearchMostRelevantParams = {
+    productIds: string[];
+    filters: any;
+    limits: any;
+    mainGender: any;
+    shop: Shops;
+};
+export type TermSearchDefaultParams = {
+    productIds: string[];
+    filters: any;
+    limits: any;
+    mainGender: any;
+    shop: Shops;
+    fields: any;
+};
+export type SortByTermRelevanceParams = {
+    productIds: string[];
+    totalResult: any;
+    limits: any;
+    filters: any;
+    fieldsHelper: any;
+};

package/services/catalog/types/fetch-products-options.type.d.ts

@@ -0,0 +1,8 @@
+import { ProductGender } from '@infrab4a/connect';
+import { ProductSort } from './product-sort.type';
+export type FetchProductsOptions = {
+    page?: number;
+    perPage?: number;
+    sort?: ProductSort;
+    mainGender?: ProductGender;
+};

package/services/catalog/types/fetch-products-params.type.d.ts

@@ -0,0 +1,25 @@
+import { Category } from '@infrab4a/connect';
+import { CatalogFilters } from '../../../interfaces';
+import { FetchProductsOptions } from './fetch-products-options.type';
+export type FetchProductsMainParams<T extends Category> = {
+    category?: T;
+    profile?: string[];
+    term?: string;
+};
+export type FetchProductsParams<T extends Category> = 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;
+    };
+});

package/services/catalog/types/fetch-products-response.type.d.ts

@@ -0,0 +1,19 @@
+import { Product } from '@infrab4a/connect';
+export type FetchProductsResponse = {
+    products: {
+        data: Product[];
+        total: number;
+    };
+    pages: number;
+    prices: {
+        price: {
+            min: number;
+            max: number;
+        };
+        subscriberPrice: {
+            min: number;
+            max: number;
+        };
+    };
+    brands?: string[];
+};

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

@@ -1 +1,5 @@
-export * from './product-sort.type';
+export * from './fetch-products-options.type';
+export * from './fetch-products-params.type';
+export * from './fetch-products-response.type';
+export * from './method-params.type';
+export * from './product-sort.type';

package/services/catalog/types/method-params.type.d.ts

@@ -0,0 +1,17 @@
+import { Category, Product, Shops } from '@infrab4a/connect';
+import { CatalogSearchParams } from '../../../interfaces';
+import { FetchProductsParams } from './fetch-products-params.type';
+export type StockNotificationParams = {
+    shop: Shops;
+    productId: string;
+    name: string;
+    email: string;
+};
+export type BuildResponseParams<T extends Category = Category> = {
+    data: Product[];
+    total: number;
+    maximum: any;
+    minimal: any;
+    searchParams: CatalogSearchParams;
+    options: FetchProductsParams<T>;
+};

package/services/catalog/types/product-sort.type.d.ts

@@ -1,2 +1,2 @@
-import { ProductSorts } from '../enums';
-export type ProductSort = `${ProductSorts}`;
+import { ProductSorts } from '../enums';
+export type ProductSort = `${ProductSorts}`;

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

@@ -1,38 +1,58 @@
-import { CategoryFilterRepository, CategoryRepository, ProductRepository, ProductsIndex, Shops, Wishlist, WishlistRepository } from '@infrab4a/connect';
-import { CatalogService } from './catalog.service';
-import { CategoryService } from './category.service';
-import * as i0 from "@angular/core";
-export declare class WishlistService {
-    private readonly wishlistRepository;
-    private readonly shop;
-    private catalogService;
-    private categoryService;
-    constructor(wishlistRepository: WishlistRepository, shop: Shops, productRepository: ProductRepository, categoryFilterRepository: CategoryFilterRepository, categoryRepository: CategoryRepository, productIndex: ProductsIndex);
-    getCatalogService(): CatalogService<import("@infrab4a/connect").Category>;
-    getCategoryService(): CategoryService;
-    create({ personId, title, description, userFullName, userPhoto, theme, bannerUrl, }: {
-        personId: string;
-        title: string;
-        description: string;
-        userFullName: string;
-        userPhoto?: string;
-        theme?: string;
-        bannerUrl?: string;
-    }): Promise<Wishlist>;
-    update({ id, title, description, userFullName, userPhoto, theme, bannerUrl, }: {
-        id: string;
-        title: string;
-        description: string;
-        userFullName: string;
-        userPhoto?: string;
-        theme?: string;
-        bannerUrl?: string;
-    }): 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>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WishlistService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WishlistService>;
-}
+import { LogRepository, PersonType, Shops, Wishlist, WishlistRepository } from '@infrab4a/connect';
+import { CatalogService } from './catalog.service';
+import { CategoryService } from './category.service';
+import { CatalogServiceFacade, CategoryServiceFacade } from './facades';
+import * as i0 from "@angular/core";
+export declare class WishlistService {
+    private readonly wishlistRepository;
+    private readonly shop;
+    private readonly logRepository;
+    private catalogService;
+    private categoryService;
+    constructor(wishlistRepository: WishlistRepository, shop: Shops, logRepository: LogRepository);
+    initializeServices(catalogServiceFacade: CatalogServiceFacade, categoryServiceFacade: CategoryServiceFacade): void;
+    getCatalogService(): CatalogService<import("@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>;
+}

package/services/checkout/checkout-dependencies.facade.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from '@angular/common/http';
+import { DataPersistence } from '../../persistence';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/services/checkout/checkout-repositories.facade.d.ts

@@ -0,0 +1,9 @@
+import { CheckoutRepository, UserRepository } from '@infrab4a/connect';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/services/checkout/index.d.ts

@@ -0,0 +1,2 @@
+export { CheckoutRepositoriesFacade } from './checkout-repositories.facade';
+export { CheckoutDependenciesFacade } from './checkout-dependencies.facade';

package/services/checkout-subscription.service.d.ts

@@ -1,19 +1,19 @@
-import { CheckoutSubscription, CheckoutSubscriptionRepository, Coupon } from '@infrab4a/connect';
-import { Observable } from 'rxjs';
-import { RequiredCheckoutSubscriptionData } from './types';
-import { DataPersistence } from '../persistence';
-import { CouponService } from './coupon.service';
-import * as i0 from "@angular/core";
-export 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>;
-}
+import { CheckoutSubscription, CheckoutSubscriptionRepository, Coupon } from '@infrab4a/connect';
+import { Observable } from 'rxjs';
+import { DataPersistence } from '../persistence';
+import { RequiredCheckoutSubscriptionData } from './types';
+import { CouponService } from './coupon.service';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/services/checkout.service.d.ts

@@ -1,24 +1,30 @@
-import { Checkout, CheckoutRepository, CheckoutTypes, Coupon, Shops, User, UserRepository } from '@infrab4a/connect';
-import { Observable } from 'rxjs';
-import { DataPersistence } from '../persistence';
-import { CouponService } from './coupon.service';
-import { RequiredCheckoutData } from './types';
-import * as i0 from "@angular/core";
-export declare class CheckoutService {
-    private readonly couponService;
-    private readonly checkoutRepository;
-    private readonly userRepository;
-    private readonly defaultShop;
-    private readonly dataPersistence;
-    constructor(couponService: CouponService, checkoutRepository: CheckoutRepository, userRepository: UserRepository, defaultShop: Shops, dataPersistence: DataPersistence);
-    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>;
-    calcDiscount(coupon: Coupon): Observable<number>;
-    checkCoupon(nickname: string, checkoutType: CheckoutTypes): Observable<Coupon>;
-    private createCheckout;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CheckoutService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<CheckoutService>;
-}
+import { Checkout, CheckoutPayloadRequest, CheckoutResponse, CheckoutStockValidation, CheckoutTypes, Coupon, ShippingMethodResponse, ShippingProductRequest, User, UserAddress } from '@infrab4a/connect';
+import { Observable } from 'rxjs';
+import { RequiredCheckoutData } from './types';
+import { CheckoutDependenciesFacade, CheckoutRepositoriesFacade } from './checkout';
+import { ConfigurationFacade } from './shared';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/services/coupon/coupon-repositories.facade.d.ts

@@ -0,0 +1,10 @@
+import { CategoryRepository, CouponRepository, OrderRepository } from '@infrab4a/connect';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/services/coupon/index.d.ts

@@ -0,0 +1 @@
+export { CouponRepositoriesFacade } from './coupon-repositories.facade';

package/services/coupon/types/coupon-params.type.d.ts

@@ -0,0 +1,13 @@
+import { Checkout, CheckoutTypes, Coupon } from '@infrab4a/connect';
+export type CheckCouponParams = {
+    nickname: string;
+    checkoutType: CheckoutTypes;
+    checkout: Partial<Checkout>;
+    plan: string;
+};
+export type CouponRulesValidationParams = {
+    coupon: Coupon;
+    checkoutType: CheckoutTypes;
+    checkout: Partial<Checkout>;
+    plan: string;
+};