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

package/{fesm2020 → fesm2022}/infrab4a-connect-angular.mjs

@@ -7,7 +7,7 @@ import { provideAppCheck, initializeAppCheck } from '@angular/fire/app-check';
 import * as i3$1 from '@angular/fire/storage';
 import { Storage, provideStorage, getStorage } from '@angular/fire/storage';
 import * as i3 from '@infrab4a/connect';
-import { ProductsIndex, AxiosAdapter, Authentication, AuthenticationFirebaseAuthService, Register, RegisterFirebaseAuthService, SignOut, RecoveryPassword, ConnectFirestoreService, UserBeautyProfileFirestoreRepository, Buy2WinFirestoreRepository, CategoryFirestoreRepository, CheckoutFirestoreRepository, CheckoutSubscriptionFirestoreRepository, CouponFirestoreRepository, CampaignHashtagFirestoreRepository, CampaignDashboardFirestoreRepository, SubscriptionEditionFirestoreRepository, GroupFirestoreRepository, HomeFirestoreRepository, LeadFirestoreRepository, LegacyOrderFirestoreRepository, ShopMenuFirestoreRepository, OrderFirestoreRepository, PaymentFirestoreRepository, ProductFirestoreRepository, ShopSettingsFirestoreRepository, SubscriptionPaymentFirestoreRepository, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, SubscriptionFirestoreRepository, UserFirestoreRepository, UserAddressFirestoreRepository, UserPaymentMethodFirestoreRepository, SubscriptionMaterializationFirestoreRepository, SubscriptionSummaryFirestoreRepository, ProductVariantFirestoreRepository, OrderBlockedFirestoreRepository, LogFirestoreRepository, SequenceFirestoreRepository, CategoryHasuraGraphQLRepository, ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository, ProductReviewHasuraGraphQLRepository, VariantHasuraGraphQLRepository, ProductStockNotificationHasuraGraphQLRepository, FilterOptionHasuraGraphQLRepository, FilterHasuraGraphQLRepository, CategoryCollectionChildrenHasuraGraphQLRepository, CategoryProductHasuraGraphQLRepository, WishlistHasuraGraphQLRepository, ProductErrorsHasuraGraphQLRepository, ProductsVertexSearch, VertexAxiosAdapter, isNil, NotFoundError, Checkout, pick, LineItem, Where, Shops, isEmpty, set, InvalidArgumentError, RoundProductPricesHelper, Category, WishlistLogType, PersonTypes, Wishlist, CheckoutTypes, CouponTypes, Exclusivities, OrderStatus, CheckoutSubscription, Product, RequiredArgumentError, add, Order, UpdateUserImage, FirebaseFileUploaderService } from '@infrab4a/connect';
+import { ProductsIndex, AxiosAdapter, Authentication, AuthenticationFirebaseAuthService, Register, RegisterFirebaseAuthService, SignOut, RecoveryPassword, ConnectFirestoreService, UserBeautyProfileFirestoreRepository, Buy2WinFirestoreRepository, CategoryFirestoreRepository, CheckoutFirestoreRepository, CheckoutSubscriptionFirestoreRepository, CouponFirestoreRepository, CampaignHashtagFirestoreRepository, CampaignDashboardFirestoreRepository, SubscriptionEditionFirestoreRepository, GroupFirestoreRepository, HomeFirestoreRepository, LeadFirestoreRepository, LegacyOrderFirestoreRepository, ShopMenuFirestoreRepository, OrderFirestoreRepository, PaymentFirestoreRepository, ProductFirestoreRepository, ShopSettingsFirestoreRepository, SubscriptionPaymentFirestoreRepository, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, SubscriptionFirestoreRepository, UserFirestoreRepository, UserAddressFirestoreRepository, UserPaymentMethodFirestoreRepository, SubscriptionMaterializationFirestoreRepository, SubscriptionSummaryFirestoreRepository, ProductVariantFirestoreRepository, OrderBlockedFirestoreRepository, LogFirestoreRepository, SequenceFirestoreRepository, CategoryHasuraGraphQLRepository, ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository, ProductReviewHasuraGraphQLRepository, VariantHasuraGraphQLRepository, ProductStockNotificationHasuraGraphQLRepository, FilterOptionHasuraGraphQLRepository, FilterHasuraGraphQLRepository, CategoryCollectionChildrenHasuraGraphQLRepository, CategoryProductHasuraGraphQLRepository, WishlistHasuraGraphQLRepository, ProductErrorsHasuraGraphQLRepository, ProductsVertexSearch, VertexAxiosAdapter, isNil, NotFoundError, Checkout, pick, LineItem, Where, isEmpty, Shops, set, InvalidArgumentError, RoundProductPricesHelper, Category, WishlistLogType, PersonTypes, Wishlist, CheckoutTypes, CouponTypes, Exclusivities, OrderStatus, CheckoutSubscription, Product, RequiredArgumentError, add, ProductReview, Order, UpdateUserImage, FirebaseFileUploaderService } from '@infrab4a/connect';
 import * as i1 from '@angular/fire/auth';
 import { Auth, provideAuth, initializeAuth, indexedDBLocalPersistence, browserLocalPersistence, browserSessionPersistence, getAuth, getIdToken, authState } from '@angular/fire/auth';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
@@ -29,17 +29,17 @@ class AngularElasticSeachModule {
             providers: [{ provide: ES_CONFIG, useValue: options }],
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularElasticSeachModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.3", ngImport: i0, type: AngularElasticSeachModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularElasticSeachModule, providers: [
+            {
+                provide: ProductsIndex,
+                useFactory: (configuration) => new ProductsIndex(new AxiosAdapter(configuration)),
+                deps: [ES_CONFIG],
+            },
+        ] }); }
 }
-AngularElasticSeachModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularElasticSeachModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule });
-AngularElasticSeachModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule, providers: [
-        {
-            provide: ProductsIndex,
-            useFactory: (configuration) => new ProductsIndex(new AxiosAdapter(configuration)),
-            deps: [ES_CONFIG],
-        },
-    ] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularElasticSeachModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularElasticSeachModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [
@@ -78,66 +78,66 @@ class AngularFirebaseAuthModule {
             ],
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularFirebaseAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.3", ngImport: i0, type: AngularFirebaseAuthModule, imports: [i1.AuthModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularFirebaseAuthModule, providers: [
+            {
+                provide: 'Authentication',
+                useFactory: (authenticationService, userRepository) => {
+                    return new Authentication(authenticationService, userRepository);
+                },
+                deps: ['AuthenticationService', 'UserRepository'],
+            },
+            {
+                provide: 'AuthenticationService',
+                useFactory: (angularFireAuth) => {
+                    return new AuthenticationFirebaseAuthService(angularFireAuth);
+                },
+                deps: [Auth],
+            },
+            {
+                provide: 'Register',
+                useFactory: (registerService, userRepository) => {
+                    return new Register(registerService, userRepository);
+                },
+                deps: ['RegisterService', 'UserRepository'],
+            },
+            {
+                provide: 'RegisterService',
+                useFactory: (angularFireAuth) => {
+                    return new RegisterFirebaseAuthService(angularFireAuth);
+                },
+                deps: [Auth],
+            },
+            {
+                provide: 'SignOut',
+                useFactory: (authenticationService) => {
+                    return new SignOut(authenticationService);
+                },
+                deps: ['AuthenticationService'],
+            },
+            {
+                provide: 'RecoveryPassword',
+                useFactory: (authenticationService) => {
+                    return new RecoveryPassword(authenticationService);
+                },
+                deps: ['AuthenticationService'],
+            },
+        ], imports: [provideAuth((injector) => {
+                const app = injector.get(FirebaseApp);
+                try {
+                    return initializeAuth(app, {
+                        persistence: [indexedDBLocalPersistence, browserLocalPersistence, browserSessionPersistence],
+                    });
+                }
+                catch (error) {
+                    if (error instanceof Error)
+                        console.error('Error initializing auth', error.message);
+                    return getAuth(app);
+                }
+            })] }); }
 }
-AngularFirebaseAuthModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularFirebaseAuthModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, imports: [i1.AuthModule] });
-AngularFirebaseAuthModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, providers: [
-        {
-            provide: 'Authentication',
-            useFactory: (authenticationService, userRepository) => {
-                return new Authentication(authenticationService, userRepository);
-            },
-            deps: ['AuthenticationService', 'UserRepository'],
-        },
-        {
-            provide: 'AuthenticationService',
-            useFactory: (angularFireAuth) => {
-                return new AuthenticationFirebaseAuthService(angularFireAuth);
-            },
-            deps: [Auth],
-        },
-        {
-            provide: 'Register',
-            useFactory: (registerService, userRepository) => {
-                return new Register(registerService, userRepository);
-            },
-            deps: ['RegisterService', 'UserRepository'],
-        },
-        {
-            provide: 'RegisterService',
-            useFactory: (angularFireAuth) => {
-                return new RegisterFirebaseAuthService(angularFireAuth);
-            },
-            deps: [Auth],
-        },
-        {
-            provide: 'SignOut',
-            useFactory: (authenticationService) => {
-                return new SignOut(authenticationService);
-            },
-            deps: ['AuthenticationService'],
-        },
-        {
-            provide: 'RecoveryPassword',
-            useFactory: (authenticationService) => {
-                return new RecoveryPassword(authenticationService);
-            },
-            deps: ['AuthenticationService'],
-        },
-    ], imports: [provideAuth((injector) => {
-            const app = injector.get(FirebaseApp);
-            try {
-                return initializeAuth(app, {
-                    persistence: [indexedDBLocalPersistence, browserLocalPersistence, browserSessionPersistence],
-                });
-            }
-            catch (error) {
-                if (error instanceof Error)
-                    console.error('Error initializing auth', error.message);
-                return getAuth(app);
-            }
-        })] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirebaseAuthModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularFirebaseAuthModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -220,264 +220,264 @@ class AngularFirestoreModule {
             ],
         };
     }
-}
-AngularFirestoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularFirestoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, imports: [AngularElasticSeachModule, i1$1.FirestoreModule] });
-AngularFirestoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, providers: [
-        {
-            provide: 'FirestoreOptions',
-            useFactory: (firestore, platformId) => ({
-                firestore: new ConnectFirestoreService(firestore),
-                interceptors: {
-                    request: (request) => {
-                        if (isPlatformBrowser(platformId))
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularFirestoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.3", ngImport: i0, type: AngularFirestoreModule, imports: [AngularElasticSeachModule, i1$1.FirestoreModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularFirestoreModule, providers: [
+            {
+                provide: 'FirestoreOptions',
+                useFactory: (firestore, platformId) => ({
+                    firestore: new ConnectFirestoreService(firestore),
+                    interceptors: {
+                        request: (request) => {
+                            if (isPlatformBrowser(platformId))
+                                return request;
+                            const interval = setInterval(() => { }, 100);
+                            request.interval = interval;
                             return request;
-                        const interval = setInterval(() => { }, 100);
-                        request.interval = interval;
-                        return request;
-                    },
-                    response: (response, request) => {
-                        if (isPlatformBrowser(platformId))
+                        },
+                        response: (response, request) => {
+                            if (isPlatformBrowser(platformId))
+                                return response;
+                            clearInterval(request.interval);
                             return response;
-                        clearInterval(request.interval);
-                        return response;
+                        },
                     },
+                }),
+                deps: [Firestore, PLATFORM_ID],
+            },
+            {
+                provide: 'BeautyProfileRepository',
+                useFactory: (config, userRepository) => {
+                    return new UserBeautyProfileFirestoreRepository(config, userRepository);
                 },
-            }),
-            deps: [Firestore, PLATFORM_ID],
-        },
-        {
-            provide: 'BeautyProfileRepository',
-            useFactory: (config, userRepository) => {
-                return new UserBeautyProfileFirestoreRepository(config, userRepository);
-            },
-            deps: ['FirestoreOptions', 'UserRepository'],
-        },
-        {
-            provide: 'Buy2WinRepository',
-            useFactory: (options) => {
-                return new Buy2WinFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: CategoryFirestoreRepository,
-            useFactory: (options) => {
-                return new CategoryFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'CheckoutRepository',
-            useFactory: (options) => {
-                return new CheckoutFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'CheckoutSubscriptionRepository',
-            useFactory: (options) => {
-                return new CheckoutSubscriptionFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'CouponRepository',
-            useFactory: (options) => {
-                return new CouponFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'CampaignHashtagRepository',
-            useFactory: (options) => {
-                return new CampaignHashtagFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'CampaignDashboardRepository',
-            useFactory: (options) => {
-                return new CampaignDashboardFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'EditionRepository',
-            useFactory: (options, subscriptionRepository) => {
-                return new SubscriptionEditionFirestoreRepository(options, subscriptionRepository);
-            },
-            deps: ['FirestoreOptions', 'SubscriptionRepository'],
-        },
-        {
-            provide: 'GroupRepository',
-            useFactory: (options) => {
-                return new GroupFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'HomeRepository',
-            useFactory: (options) => {
-                return new HomeFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'LeadRepository',
-            useFactory: (options) => {
-                return new LeadFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'LegacyOrderRepository',
-            useFactory: (options) => {
-                return new LegacyOrderFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'ShopMenuRepository',
-            useFactory: (options) => {
-                return new ShopMenuFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'OrderRepository',
-            useFactory: (options) => {
-                return new OrderFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'PaymentRepository',
-            useFactory: (options) => {
-                return new PaymentFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: ProductFirestoreRepository,
-            useFactory: (options) => {
-                return new ProductFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'ShopSettingsRepository',
-            useFactory: (options) => {
-                return new ShopSettingsFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'SubscriptionPaymentRepository',
-            useFactory: (options, subscriptionRepository) => {
-                return new SubscriptionPaymentFirestoreRepository(options, subscriptionRepository);
-            },
-            deps: ['FirestoreOptions', 'SubscriptionRepository'],
-        },
-        {
-            provide: 'SubscriptionPlanRepository',
-            useFactory: (options) => {
-                return new SubscriptionPlanFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'SubscriptionProductRepository',
-            useFactory: (options) => {
-                return new SubscriptionProductFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'SubscriptionRepository',
-            useFactory: (options) => {
-                return new SubscriptionFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'UserRepository',
-            useFactory: (options) => {
-                return new UserFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'UserAddressRepository',
-            useFactory: (options, userRepository) => {
-                return new UserAddressFirestoreRepository(options, userRepository);
-            },
-            deps: ['FirestoreOptions', 'UserRepository'],
-        },
-        {
-            provide: 'UserPaymentMethodRepository',
-            useFactory: (options, userRepository) => {
-                return new UserPaymentMethodFirestoreRepository(options, userRepository);
-            },
-            deps: ['FirestoreOptions', 'UserRepository'],
-        },
-        {
-            provide: 'SubscriptionMaterializationRepository',
-            useFactory: (options) => {
-                return new SubscriptionMaterializationFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'SubscriptionSummaryRepository',
-            useFactory: (options) => {
-                return new SubscriptionSummaryFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: ProductVariantFirestoreRepository,
-            useFactory: (options, productRepository) => {
-                return new ProductVariantFirestoreRepository(options, productRepository);
-            },
-            deps: ['FirestoreOptions', ProductFirestoreRepository],
-        },
-        {
-            provide: 'OrderBlockedRepository',
-            useFactory: (options) => {
-                return new OrderBlockedFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'LogRepository',
-            useFactory: (options) => {
-                return new LogFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-        {
-            provide: 'SequenceRepository',
-            useFactory: (options) => {
-                return new SequenceFirestoreRepository(options);
-            },
-            deps: ['FirestoreOptions'],
-        },
-    ], imports: [AngularElasticSeachModule,
-        provideFirestore((injector) => {
-            const platformId = injector.get(PLATFORM_ID);
-            if (isPlatformServer(platformId) || !MobileOperationSystemCheckerHelper.isAppleDevice())
-                return initializeFirestore(injector.get(FirebaseApp), {
+                deps: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'Buy2WinRepository',
+                useFactory: (options) => {
+                    return new Buy2WinFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: CategoryFirestoreRepository,
+                useFactory: (options) => {
+                    return new CategoryFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CheckoutRepository',
+                useFactory: (options) => {
+                    return new CheckoutFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CheckoutSubscriptionRepository',
+                useFactory: (options) => {
+                    return new CheckoutSubscriptionFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CouponRepository',
+                useFactory: (options) => {
+                    return new CouponFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CampaignHashtagRepository',
+                useFactory: (options) => {
+                    return new CampaignHashtagFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CampaignDashboardRepository',
+                useFactory: (options) => {
+                    return new CampaignDashboardFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'EditionRepository',
+                useFactory: (options, subscriptionRepository) => {
+                    return new SubscriptionEditionFirestoreRepository(options, subscriptionRepository);
+                },
+                deps: ['FirestoreOptions', 'SubscriptionRepository'],
+            },
+            {
+                provide: 'GroupRepository',
+                useFactory: (options) => {
+                    return new GroupFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'HomeRepository',
+                useFactory: (options) => {
+                    return new HomeFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'LeadRepository',
+                useFactory: (options) => {
+                    return new LeadFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'LegacyOrderRepository',
+                useFactory: (options) => {
+                    return new LegacyOrderFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'ShopMenuRepository',
+                useFactory: (options) => {
+                    return new ShopMenuFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'OrderRepository',
+                useFactory: (options) => {
+                    return new OrderFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'PaymentRepository',
+                useFactory: (options) => {
+                    return new PaymentFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: ProductFirestoreRepository,
+                useFactory: (options) => {
+                    return new ProductFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'ShopSettingsRepository',
+                useFactory: (options) => {
+                    return new ShopSettingsFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionPaymentRepository',
+                useFactory: (options, subscriptionRepository) => {
+                    return new SubscriptionPaymentFirestoreRepository(options, subscriptionRepository);
+                },
+                deps: ['FirestoreOptions', 'SubscriptionRepository'],
+            },
+            {
+                provide: 'SubscriptionPlanRepository',
+                useFactory: (options) => {
+                    return new SubscriptionPlanFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionProductRepository',
+                useFactory: (options) => {
+                    return new SubscriptionProductFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionRepository',
+                useFactory: (options) => {
+                    return new SubscriptionFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'UserRepository',
+                useFactory: (options) => {
+                    return new UserFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'UserAddressRepository',
+                useFactory: (options, userRepository) => {
+                    return new UserAddressFirestoreRepository(options, userRepository);
+                },
+                deps: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'UserPaymentMethodRepository',
+                useFactory: (options, userRepository) => {
+                    return new UserPaymentMethodFirestoreRepository(options, userRepository);
+                },
+                deps: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'SubscriptionMaterializationRepository',
+                useFactory: (options) => {
+                    return new SubscriptionMaterializationFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionSummaryRepository',
+                useFactory: (options) => {
+                    return new SubscriptionSummaryFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: ProductVariantFirestoreRepository,
+                useFactory: (options, productRepository) => {
+                    return new ProductVariantFirestoreRepository(options, productRepository);
+                },
+                deps: ['FirestoreOptions', ProductFirestoreRepository],
+            },
+            {
+                provide: 'OrderBlockedRepository',
+                useFactory: (options) => {
+                    return new OrderBlockedFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'LogRepository',
+                useFactory: (options) => {
+                    return new LogFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SequenceRepository',
+                useFactory: (options) => {
+                    return new SequenceFirestoreRepository(options);
+                },
+                deps: ['FirestoreOptions'],
+            },
+        ], imports: [AngularElasticSeachModule,
+            provideFirestore((injector) => {
+                const platformId = injector.get(PLATFORM_ID);
+                if (isPlatformServer(platformId) || !MobileOperationSystemCheckerHelper.isAppleDevice())
+                    return initializeFirestore(injector.get(FirebaseApp), {
+                        ignoreUndefinedProperties: true,
+                    });
+                const firestore = initializeFirestore(injector.get(FirebaseApp), {
+                    experimentalForceLongPolling: true,
                     ignoreUndefinedProperties: true,
+                    localCache: memoryLocalCache(),
                 });
-            const firestore = initializeFirestore(injector.get(FirebaseApp), {
-                experimentalForceLongPolling: true,
-                ignoreUndefinedProperties: true,
-                localCache: memoryLocalCache(),
-            });
-            return firestore;
-        })] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularFirestoreModule, decorators: [{
+                return firestore;
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularFirestoreModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -747,166 +747,166 @@ class AngularHasuraGraphQLModule {
             providers: [{ provide: HASURA_OPTIONS, useValue: options }],
         };
     }
-}
-AngularHasuraGraphQLModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularHasuraGraphQLModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule });
-AngularHasuraGraphQLModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule, providers: [
-        {
-            provide: 'HasuraConfig',
-            useFactory: (options, platformId) => ({
-                endpoint: options.endpoint,
-                authOptions: options.credentials,
-                cache: options.cache,
-                interceptors: {
-                    request: (request) => {
-                        if (isPlatformBrowser(platformId))
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularHasuraGraphQLModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.3", ngImport: i0, type: AngularHasuraGraphQLModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularHasuraGraphQLModule, providers: [
+            {
+                provide: 'HasuraConfig',
+                useFactory: (options, platformId) => ({
+                    endpoint: options.endpoint,
+                    authOptions: options.credentials,
+                    cache: options.cache,
+                    interceptors: {
+                        request: (request) => {
+                            if (isPlatformBrowser(platformId))
+                                return request;
+                            const interval = setInterval(() => { }, 100);
+                            request.interval = interval;
                             return request;
-                        const interval = setInterval(() => { }, 100);
-                        request.interval = interval;
-                        return request;
-                    },
-                    response: (response, request) => {
-                        if (isPlatformBrowser(platformId))
+                        },
+                        response: (response, request) => {
+                            if (isPlatformBrowser(platformId))
+                                return response;
+                            clearInterval(request.interval);
                             return response;
-                        clearInterval(request.interval);
-                        return response;
+                        },
                     },
+                }),
+                deps: [HASURA_OPTIONS, PLATFORM_ID],
+            },
+            {
+                provide: 'CategoryRepository',
+                useExisting: CategoryHasuraGraphQLRepository,
+            },
+            {
+                provide: CategoryHasuraGraphQLRepository,
+                useFactory: (options, productRepository, categoryFilterRepository) => {
+                    return new CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository);
                 },
-            }),
-            deps: [HASURA_OPTIONS, PLATFORM_ID],
-        },
-        {
-            provide: 'CategoryRepository',
-            useExisting: CategoryHasuraGraphQLRepository,
-        },
-        {
-            provide: CategoryHasuraGraphQLRepository,
-            useFactory: (options, productRepository, categoryFilterRepository) => {
-                return new CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository);
-            },
-            deps: ['HasuraConfig', ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
-        },
-        {
-            provide: 'ProductRepository',
-            useExisting: ProductHasuraGraphQLRepository,
-        },
-        {
-            provide: ProductHasuraGraphQLRepository,
-            useFactory: (hasuraConfig) => {
-                return new ProductHasuraGraphQLRepository(hasuraConfig);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'ProductReviewRepository',
-            useExisting: ProductReviewHasuraGraphQLRepository,
-        },
-        {
-            provide: ProductReviewHasuraGraphQLRepository,
-            useFactory: (hasuraConfig) => {
-                return new ProductReviewHasuraGraphQLRepository(hasuraConfig);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'VariantRepository',
-            useExisting: VariantHasuraGraphQLRepository,
-        },
-        {
-            provide: VariantHasuraGraphQLRepository,
-            useFactory: (hasuraConfig) => {
-                return new VariantHasuraGraphQLRepository(hasuraConfig);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'ProductStockNotificationRepository',
-            useExisting: ProductStockNotificationHasuraGraphQLRepository,
-        },
-        {
-            provide: ProductStockNotificationHasuraGraphQLRepository,
-            useFactory: (hasuraConfig) => {
-                return new ProductStockNotificationHasuraGraphQLRepository(hasuraConfig);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'CategoryFilterRepository',
-            useExisting: CategoryFilterHasuraGraphQLRepository,
-        },
-        {
-            provide: CategoryFilterHasuraGraphQLRepository,
-            useFactory: (options) => {
-                return new CategoryFilterHasuraGraphQLRepository(options);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'FilterOptionRepository',
-            useExisting: FilterOptionHasuraGraphQLRepository,
-        },
-        {
-            provide: FilterOptionHasuraGraphQLRepository,
-            useFactory: (options) => {
-                return new FilterOptionHasuraGraphQLRepository(options);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'FilterRepository',
-            useExisting: FilterHasuraGraphQLRepository,
-        },
-        {
-            provide: FilterHasuraGraphQLRepository,
-            useFactory: (options, filterOptionRepository, categoryFilterRepository) => {
-                return new FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository);
-            },
-            deps: ['HasuraConfig', FilterOptionHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
-        },
-        {
-            provide: CategoryCollectionChildrenHasuraGraphQLRepository,
-            useFactory: (options) => new CategoryCollectionChildrenHasuraGraphQLRepository(options),
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'CategoryCollectionChildrenRepository',
-            useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
-        },
-        {
-            provide: CategoryProductHasuraGraphQLRepository,
-            useFactory: (options) => {
-                return new CategoryProductHasuraGraphQLRepository(options);
-            },
-            deps: ['HasuraConfig'],
-        },
-        {
-            provide: 'CategoryProductRepository',
-            useExisting: CategoryProductHasuraGraphQLRepository,
-        },
-        {
-            provide: WishlistHasuraGraphQLRepository,
-            useFactory: (options, categoryProductRepository) => {
-                return new WishlistHasuraGraphQLRepository(options, categoryProductRepository);
-            },
-            deps: ['HasuraConfig', CategoryProductHasuraGraphQLRepository],
-        },
-        {
-            provide: 'WishlistRepository',
-            useExisting: WishlistHasuraGraphQLRepository,
-        },
-        {
-            provide: ProductErrorsHasuraGraphQLRepository,
-            useFactory: (options, productRepository) => {
-                return new ProductErrorsHasuraGraphQLRepository(options, productRepository);
-            },
-            deps: ['HasuraConfig', ProductHasuraGraphQLRepository],
-        },
-        {
-            provide: 'ProductErrorsRepository',
-            useExisting: ProductErrorsHasuraGraphQLRepository,
-        },
-    ] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularHasuraGraphQLModule, decorators: [{
+                deps: ['HasuraConfig', ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
+            },
+            {
+                provide: 'ProductRepository',
+                useExisting: ProductHasuraGraphQLRepository,
+            },
+            {
+                provide: ProductHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new ProductHasuraGraphQLRepository(hasuraConfig);
+                },
+                deps: ['HasuraConfig'],
+            },
+            {
+                provide: 'ProductReviewRepository',
+                useExisting: ProductReviewHasuraGraphQLRepository,
+            },
+            {
+                provide: ProductReviewHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new ProductReviewHasuraGraphQLRepository(hasuraConfig);
+                },
+                deps: ['HasuraConfig'],
+            },
+            {
+                provide: 'VariantRepository',
+                useExisting: VariantHasuraGraphQLRepository,
+            },
+            {
+                provide: VariantHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new VariantHasuraGraphQLRepository(hasuraConfig);
+                },
+                deps: ['HasuraConfig'],
+            },
+            {
+                provide: 'ProductStockNotificationRepository',
+                useExisting: ProductStockNotificationHasuraGraphQLRepository,
+            },
+            {
+                provide: ProductStockNotificationHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new ProductStockNotificationHasuraGraphQLRepository(hasuraConfig);
+                },
+                deps: ['HasuraConfig'],
+            },
+            {
+                provide: 'CategoryFilterRepository',
+                useExisting: CategoryFilterHasuraGraphQLRepository,
+            },
+            {
+                provide: CategoryFilterHasuraGraphQLRepository,
+                useFactory: (options) => {
+                    return new CategoryFilterHasuraGraphQLRepository(options);
+                },
+                deps: ['HasuraConfig'],
+            },
+            {
+                provide: 'FilterOptionRepository',
+                useExisting: FilterOptionHasuraGraphQLRepository,
+            },
+            {
+                provide: FilterOptionHasuraGraphQLRepository,
+                useFactory: (options) => {
+                    return new FilterOptionHasuraGraphQLRepository(options);
+                },
+                deps: ['HasuraConfig'],
+            },
+            {
+                provide: 'FilterRepository',
+                useExisting: FilterHasuraGraphQLRepository,
+            },
+            {
+                provide: FilterHasuraGraphQLRepository,
+                useFactory: (options, filterOptionRepository, categoryFilterRepository) => {
+                    return new FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository);
+                },
+                deps: ['HasuraConfig', FilterOptionHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
+            },
+            {
+                provide: CategoryCollectionChildrenHasuraGraphQLRepository,
+                useFactory: (options) => new CategoryCollectionChildrenHasuraGraphQLRepository(options),
+                deps: ['HasuraConfig'],
+            },
+            {
+                provide: 'CategoryCollectionChildrenRepository',
+                useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
+            },
+            {
+                provide: CategoryProductHasuraGraphQLRepository,
+                useFactory: (options) => {
+                    return new CategoryProductHasuraGraphQLRepository(options);
+                },
+                deps: ['HasuraConfig'],
+            },
+            {
+                provide: 'CategoryProductRepository',
+                useExisting: CategoryProductHasuraGraphQLRepository,
+            },
+            {
+                provide: WishlistHasuraGraphQLRepository,
+                useFactory: (options, categoryProductRepository) => {
+                    return new WishlistHasuraGraphQLRepository(options, categoryProductRepository);
+                },
+                deps: ['HasuraConfig', CategoryProductHasuraGraphQLRepository],
+            },
+            {
+                provide: 'WishlistRepository',
+                useExisting: WishlistHasuraGraphQLRepository,
+            },
+            {
+                provide: ProductErrorsHasuraGraphQLRepository,
+                useFactory: (options, productRepository) => {
+                    return new ProductErrorsHasuraGraphQLRepository(options, productRepository);
+                },
+                deps: ['HasuraConfig', ProductHasuraGraphQLRepository],
+            },
+            {
+                provide: 'ProductErrorsRepository',
+                useExisting: ProductErrorsHasuraGraphQLRepository,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularHasuraGraphQLModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [
@@ -1075,17 +1075,17 @@ class AngularVertexSeachModule {
             providers: [{ provide: VERTEX_CONFIG, useValue: options }],
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularVertexSeachModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.3", ngImport: i0, type: AngularVertexSeachModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularVertexSeachModule, providers: [
+            {
+                provide: ProductsVertexSearch,
+                useFactory: (configuration) => new ProductsVertexSearch(new VertexAxiosAdapter(configuration)),
+                deps: [VERTEX_CONFIG],
+            },
+        ] }); }
 }
-AngularVertexSeachModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularVertexSeachModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularVertexSeachModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularVertexSeachModule });
-AngularVertexSeachModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularVertexSeachModule, providers: [
-        {
-            provide: ProductsVertexSearch,
-            useFactory: (configuration) => new ProductsVertexSearch(new VertexAxiosAdapter(configuration)),
-            deps: [VERTEX_CONFIG],
-        },
-    ] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularVertexSeachModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularVertexSeachModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [
@@ -1110,10 +1110,10 @@ class CookieDataPersistence {
     set(key, value) {
         return from(cookie.set(key, value)).pipe(map(() => { }));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CookieDataPersistence, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CookieDataPersistence }); }
 }
-CookieDataPersistence.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CookieDataPersistence, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-CookieDataPersistence.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CookieDataPersistence });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CookieDataPersistence, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CookieDataPersistence, decorators: [{
             type: Injectable
         }] });
 
@@ -1138,48 +1138,48 @@ class AuthService {
     getFireUser() {
         return authState(this.angularFireAuth).pipe(catchError(() => of(null)));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AuthService, deps: [{ token: i1.Auth }, { token: 'UserRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AuthService }); }
 }
-AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AuthService, deps: [{ token: i1.Auth }, { token: 'UserRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AuthService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AuthService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AuthService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.Auth }, { type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: i1.Auth }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['UserRepository']
-                }] }]; } });
+                }] }] });
 
 class CheckoutRepositoriesFacade {
     constructor(checkoutRepository, userRepository) {
         this.checkoutRepository = checkoutRepository;
         this.userRepository = userRepository;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutRepositoriesFacade, deps: [{ token: 'CheckoutRepository' }, { token: 'UserRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutRepositoriesFacade }); }
 }
-CheckoutRepositoriesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutRepositoriesFacade, deps: [{ token: 'CheckoutRepository' }, { token: 'UserRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-CheckoutRepositoriesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutRepositoriesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutRepositoriesFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutRepositoriesFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['CheckoutRepository']
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['UserRepository']
-                }] }]; } });
+                }] }] });
 
 class CheckoutDependenciesFacade {
     constructor(dataPersistence, httpClient) {
         this.dataPersistence = dataPersistence;
         this.httpClient = httpClient;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutDependenciesFacade, deps: [{ token: PERSISTENCE_PROVIDER }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutDependenciesFacade }); }
 }
-CheckoutDependenciesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutDependenciesFacade, deps: [{ token: PERSISTENCE_PROVIDER }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-CheckoutDependenciesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutDependenciesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutDependenciesFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutDependenciesFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [PERSISTENCE_PROVIDER]
-                }] }, { type: i1$2.HttpClient }]; } });
+                }] }, { type: i1$2.HttpClient }] });
 
 class ConfigurationFacade {
     constructor(defaultShop, firebaseOptions) {
@@ -1192,18 +1192,18 @@ class ConfigurationFacade {
     getProjectId() {
         return this.firebaseOptions.projectId;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ConfigurationFacade, deps: [{ token: DEFAULT_SHOP }, { token: FIREBASE_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ConfigurationFacade }); }
 }
-ConfigurationFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ConfigurationFacade, deps: [{ token: DEFAULT_SHOP }, { token: FIREBASE_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable });
-ConfigurationFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ConfigurationFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ConfigurationFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ConfigurationFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i3.Shops, decorators: [{
+        }], ctorParameters: () => [{ type: i3.Shops, decorators: [{
                     type: Inject,
                     args: [DEFAULT_SHOP]
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [FIREBASE_OPTIONS]
-                }] }]; } });
+                }] }] });
 
 class CheckoutService {
     constructor(repositoriesFacade, dependenciesFacade, configurationFacade) {
@@ -1295,12 +1295,12 @@ class CheckoutService {
         await this.dependenciesFacade.dataPersistence.set('checkoutId', checkout.id).toPromise();
         return checkout;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutService, deps: [{ token: CheckoutRepositoriesFacade }, { token: CheckoutDependenciesFacade }, { token: ConfigurationFacade }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutService }); }
 }
-CheckoutService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutService, deps: [{ token: CheckoutRepositoriesFacade }, { token: CheckoutDependenciesFacade }, { token: ConfigurationFacade }], target: i0.ɵɵFactoryTarget.Injectable });
-CheckoutService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CheckoutRepositoriesFacade }, { type: CheckoutDependenciesFacade }, { type: ConfigurationFacade }]; } });
+        }], ctorParameters: () => [{ type: CheckoutRepositoriesFacade }, { type: CheckoutDependenciesFacade }, { type: ConfigurationFacade }] });
 
 class CartServicesFacade {
     constructor(authService, checkoutService, httpClient) {
@@ -1308,12 +1308,12 @@ class CartServicesFacade {
         this.checkoutService = checkoutService;
         this.httpClient = httpClient;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CartServicesFacade, deps: [{ token: AuthService }, { token: CheckoutService }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CartServicesFacade }); }
 }
-CartServicesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartServicesFacade, deps: [{ token: AuthService }, { token: CheckoutService }, { token: i1$2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-CartServicesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartServicesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartServicesFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CartServicesFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: AuthService }, { type: CheckoutService }, { type: i1$2.HttpClient }]; } });
+        }], ctorParameters: () => [{ type: AuthService }, { type: CheckoutService }, { type: i1$2.HttpClient }] });
 
 class CartService {
     constructor(servicesFacade, configurationFacade) {
@@ -1372,12 +1372,12 @@ class CartService {
     buildCartFromCheckout(checkoutData) {
         return this.servicesFacade.checkoutService.getCheckout(checkoutData).pipe(map((checkout) => checkout.lineItems), concatMap((lineItems) => of(this.generateCartObject(lineItems))));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CartService, deps: [{ token: CartServicesFacade }, { token: ConfigurationFacade }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CartService }); }
 }
-CartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartService, deps: [{ token: CartServicesFacade }, { token: ConfigurationFacade }], target: i0.ɵɵFactoryTarget.Injectable });
-CartService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CartService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CartService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CartServicesFacade }, { type: ConfigurationFacade }]; } });
+        }], ctorParameters: () => [{ type: CartServicesFacade }, { type: ConfigurationFacade }] });
 
 class NewCategoryStructureAdapter {
     constructor(categoryRepository) {
@@ -1409,15 +1409,15 @@ class NewCategoryStructureAdapter {
             category.brandCategory;
         return collectionCategory ? this.categoryRepository.get({ id: category.id }) : category;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: NewCategoryStructureAdapter, deps: [{ token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: NewCategoryStructureAdapter }); }
 }
-NewCategoryStructureAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NewCategoryStructureAdapter, deps: [{ token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-NewCategoryStructureAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NewCategoryStructureAdapter });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NewCategoryStructureAdapter, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: NewCategoryStructureAdapter, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['CategoryRepository']
-                }] }]; } });
+                }] }] });
 
 class OldCategoryStructureAdapter {
     constructor(categoryRepository) {
@@ -1429,15 +1429,15 @@ class OldCategoryStructureAdapter {
             : await this.categoryRepository.get({ id: category.id }).then((categoryFound) => categoryFound.products);
         return { id: { operator: Where.IN, value: productsIds } };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: OldCategoryStructureAdapter, deps: [{ token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: OldCategoryStructureAdapter }); }
 }
-OldCategoryStructureAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OldCategoryStructureAdapter, deps: [{ token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-OldCategoryStructureAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OldCategoryStructureAdapter });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OldCategoryStructureAdapter, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: OldCategoryStructureAdapter, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['CategoryRepository']
-                }] }]; } });
+                }] }] });
 
 class CatalogSearchContext {
     constructor(categoryStrategy, termStrategy, profileStrategy) {
@@ -1528,7 +1528,7 @@ class CategorySearchStrategy {
         });
     }
     async searchDefault(params) {
-        const { category, filters, limits, shop, mainGender, sort, optionsCache, fields } = params;
+        const { category, filters, limits, sort, optionsCache, fields } = params;
         const productCatalog = this.repositoryService.getProductCatalog();
         const filterHelper = this.helpersService.getFilterHelper();
         const sortHelper = this.helpersService.getSortHelper();
@@ -1546,7 +1546,7 @@ class CategorySearchStrategy {
                 distinct: ['brand'],
             },
         };
-        return productCatalog.productRepository.findCatalog(repoParams, mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'), optionsCache);
+        return productCatalog.productRepository.findCatalog(repoParams, null, optionsCache);
     }
     async getProductIds(category, filters, optionsCache) {
         const productCatalog = this.repositoryService.getProductCatalog();
@@ -1600,12 +1600,12 @@ class CategorySearchStrategy {
             distinct: totalResult.distinct,
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategorySearchStrategy, deps: [{ token: CatalogRepositoryService }, { token: CatalogHelpersService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategorySearchStrategy }); }
 }
-CategorySearchStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategorySearchStrategy, deps: [{ token: CatalogRepositoryService }, { token: CatalogHelpersService }], target: i0.ɵɵFactoryTarget.Injectable });
-CategorySearchStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategorySearchStrategy });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategorySearchStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategorySearchStrategy, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogRepositoryService }, { type: CatalogHelpersService }]; } });
+        }], ctorParameters: () => [{ type: CatalogRepositoryService }, { type: CatalogHelpersService }] });
 
 class ProfileSearchStrategy {
     constructor(repositoryService, helpersService) {
@@ -1637,12 +1637,12 @@ class ProfileSearchStrategy {
         };
         return productCatalog.productRepository.findCatalog(repoParams, mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'), optionsCache);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProfileSearchStrategy, deps: [{ token: CatalogRepositoryService }, { token: CatalogHelpersService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProfileSearchStrategy }); }
 }
-ProfileSearchStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProfileSearchStrategy, deps: [{ token: CatalogRepositoryService }, { token: CatalogHelpersService }], target: i0.ɵɵFactoryTarget.Injectable });
-ProfileSearchStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProfileSearchStrategy });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProfileSearchStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProfileSearchStrategy, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogRepositoryService }, { type: CatalogHelpersService }]; } });
+        }], ctorParameters: () => [{ type: CatalogRepositoryService }, { type: CatalogHelpersService }] });
 
 class TermSearchStrategy {
     constructor(repositoryService, helpersService) {
@@ -1690,7 +1690,7 @@ class TermSearchStrategy {
                 maximum: ['price'],
                 ...(isEmpty(filters?.brands) ? { distinct: ['brand'] } : {}),
             },
-        }, mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'));
+        });
         return this.sortByTermRelevance({
             productIds,
             totalResult,
@@ -1716,22 +1716,19 @@ class TermSearchStrategy {
                 maximum: ['price'],
                 distinct: ['brand'],
             },
-        }, mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'));
+        });
     }
     sortByTermRelevance(params) {
         const { productIds, totalResult, limits, filters, fieldsHelper } = params;
-        const defaultGender = filters?.gender?.at(0) || 'male';
+        // const defaultGender = filters?.gender?.at(0) || 'male'
         const stockData = totalResult.data.filter((product) => product.stock.quantity > 0);
         const stockOut = totalResult.data.filter((product) => product.stock.quantity <= 0);
-        const productIdsStockGender = productIds.filter((product) => stockData.some((result) => result.id === product && (result.gender?.includes(defaultGender) || result.gender?.includes('unisex'))));
-        const productIdsStockNotGender = productIds.filter((product) => stockData.some((result) => result.id === product && !result.gender?.includes(defaultGender) && !result.gender?.includes('unisex')));
-        const productIdsStock = productIdsStockGender.concat(productIdsStockNotGender);
+        const productIdsStock = productIds.filter((product) => stockData.some((result) => result.id === product));
         const productIdsStockOut = productIds.filter((product) => stockOut.some((result) => result.id === product));
         const limitedProductId = productIdsStock
             .concat(productIdsStockOut)
             .slice(limits.offset, limits.offset + limits.limit);
-        const orderedId = productIds.filter((product) => limitedProductId.includes(product));
-        return this.getDetailedProducts(orderedId, totalResult, fieldsHelper);
+        return this.getDetailedProducts(limitedProductId, totalResult, fieldsHelper);
     }
     async getDetailedProducts(orderedId, totalResult, fieldsHelper) {
         const productCatalog = this.repositoryService.getProductCatalog();
@@ -1758,12 +1755,12 @@ class TermSearchStrategy {
             .search(term, 999, shop === Shops.GLAMSHOP ? 'female' : 'male')
             .then((products) => [...new Set(products.map((product) => product.id))]));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: TermSearchStrategy, deps: [{ token: CatalogRepositoryService }, { token: CatalogHelpersService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: TermSearchStrategy }); }
 }
-TermSearchStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: TermSearchStrategy, deps: [{ token: CatalogRepositoryService }, { token: CatalogHelpersService }], target: i0.ɵɵFactoryTarget.Injectable });
-TermSearchStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: TermSearchStrategy });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: TermSearchStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: TermSearchStrategy, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogRepositoryService }, { type: CatalogHelpersService }]; } });
+        }], ctorParameters: () => [{ type: CatalogRepositoryService }, { type: CatalogHelpersService }] });
 
 class CatalogStrategiesFacade {
     constructor(categoryStrategy, termStrategy, profileStrategy) {
@@ -1771,12 +1768,12 @@ class CatalogStrategiesFacade {
         this.termStrategy = termStrategy;
         this.profileStrategy = profileStrategy;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogStrategiesFacade, deps: [{ token: CategorySearchStrategy }, { token: TermSearchStrategy }, { token: ProfileSearchStrategy }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogStrategiesFacade }); }
 }
-CatalogStrategiesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogStrategiesFacade, deps: [{ token: CategorySearchStrategy }, { token: TermSearchStrategy }, { token: ProfileSearchStrategy }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogStrategiesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogStrategiesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogStrategiesFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogStrategiesFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CategorySearchStrategy }, { type: TermSearchStrategy }, { type: ProfileSearchStrategy }]; } });
+        }], ctorParameters: () => [{ type: CategorySearchStrategy }, { type: TermSearchStrategy }, { type: ProfileSearchStrategy }] });
 
 class CatalogServiceFacade {
     constructor(helpersService, strategiesFacade, shop) {
@@ -1789,33 +1786,33 @@ class CatalogServiceFacade {
     getCatalogService() {
         return this.catalogService;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogServiceFacade, deps: [{ token: CatalogHelpersService }, { token: CatalogStrategiesFacade }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogServiceFacade }); }
 }
-CatalogServiceFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogServiceFacade, deps: [{ token: CatalogHelpersService }, { token: CatalogStrategiesFacade }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogServiceFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogServiceFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogServiceFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogServiceFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogHelpersService }, { type: CatalogStrategiesFacade }, { type: i3.Shops, decorators: [{
+        }], ctorParameters: () => [{ type: CatalogHelpersService }, { type: CatalogStrategiesFacade }, { type: i3.Shops, decorators: [{
                     type: Inject,
                     args: [DEFAULT_SHOP]
-                }] }]; } });
+                }] }] });
 
 class CategoryRepositoryFacade {
     constructor(categoryRepository, categoryFilterRepository) {
         this.categoryRepository = categoryRepository;
         this.categoryFilterRepository = categoryFilterRepository;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategoryRepositoryFacade, deps: [{ token: 'CategoryRepository' }, { token: 'CategoryFilterRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategoryRepositoryFacade }); }
 }
-CategoryRepositoryFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryRepositoryFacade, deps: [{ token: 'CategoryRepository' }, { token: 'CategoryFilterRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-CategoryRepositoryFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryRepositoryFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryRepositoryFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategoryRepositoryFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['CategoryRepository']
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['CategoryFilterRepository']
-                }] }]; } });
+                }] }] });
 
 class CategoryService {
     constructor(categoryFacade, productCatalog, shop) {
@@ -1828,7 +1825,7 @@ class CategoryService {
             .findCatalog({
             filters: await this.productCatalog.categoryStructureAdapter.buildProductFilterByCategory(category),
             fields: ['brand'],
-        }, options?.mainGender ? options?.mainGender : this.shop === Shops.MENSMARKET ? 'male' : 'female', optionsCache)
+        }, null, optionsCache)
             .then(({ data }) => Object.keys(data.map((product) => product.brand).reduce((brands, brand) => ({ ...brands, [brand]: true }), {})));
         return this.categoryFacade.categoryRepository
             .find({ filters: { brandCategory: true, shop: options?.shop || this.shop }, orderBy: { name: 'asc' } }, optionsCache)
@@ -1839,33 +1836,33 @@ class CategoryService {
             .find({ filters: { categoryId: +category.id } }, optionsCache)
             .then(({ data }) => data.map((categoryFilter) => categoryFilter.filter));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategoryService, deps: [{ token: CategoryRepositoryFacade }, { token: ProductCatalogFacade }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategoryService }); }
 }
-CategoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryService, deps: [{ token: CategoryRepositoryFacade }, { token: ProductCatalogFacade }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-CategoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategoryService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CategoryRepositoryFacade }, { type: ProductCatalogFacade }, { type: i3.Shops, decorators: [{
+        }], ctorParameters: () => [{ type: CategoryRepositoryFacade }, { type: ProductCatalogFacade }, { type: i3.Shops, decorators: [{
                     type: Inject,
                     args: [DEFAULT_SHOP]
-                }] }]; } });
+                }] }] });
 
 class ProductCatalogFacade {
     constructor(productRepository, categoryStructureAdapter) {
         this.productRepository = productRepository;
         this.categoryStructureAdapter = categoryStructureAdapter;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProductCatalogFacade, deps: [{ token: 'ProductRepository' }, { token: CATEGORY_STRUCTURE }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProductCatalogFacade }); }
 }
-ProductCatalogFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductCatalogFacade, deps: [{ token: 'ProductRepository' }, { token: CATEGORY_STRUCTURE }], target: i0.ɵɵFactoryTarget.Injectable });
-ProductCatalogFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductCatalogFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductCatalogFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProductCatalogFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['ProductRepository']
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [CATEGORY_STRUCTURE]
-                }] }]; } });
+                }] }] });
 
 class CategoryServiceFacade {
     constructor(categoryRepositoryFacade, productCatalogFacade, shop) {
@@ -1877,15 +1874,15 @@ class CategoryServiceFacade {
     getCategoryService() {
         return this.categoryService;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategoryServiceFacade, deps: [{ token: CategoryRepositoryFacade }, { token: ProductCatalogFacade }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategoryServiceFacade }); }
 }
-CategoryServiceFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryServiceFacade, deps: [{ token: CategoryRepositoryFacade }, { token: ProductCatalogFacade }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-CategoryServiceFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryServiceFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CategoryServiceFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CategoryServiceFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CategoryRepositoryFacade }, { type: ProductCatalogFacade }, { type: i3.Shops, decorators: [{
+        }], ctorParameters: () => [{ type: CategoryRepositoryFacade }, { type: ProductCatalogFacade }, { type: i3.Shops, decorators: [{
                     type: Inject,
                     args: [DEFAULT_SHOP]
-                }] }]; } });
+                }] }] });
 
 class BrandManagerHelper {
     constructor(productCatalog) {
@@ -1932,12 +1929,12 @@ class BrandManagerHelper {
         }, options.mainGender)
             .then((result) => result.distinct.brand);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: BrandManagerHelper, deps: [{ token: ProductCatalogFacade }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: BrandManagerHelper }); }
 }
-BrandManagerHelper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: BrandManagerHelper, deps: [{ token: ProductCatalogFacade }], target: i0.ɵɵFactoryTarget.Injectable });
-BrandManagerHelper.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: BrandManagerHelper });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: BrandManagerHelper, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: BrandManagerHelper, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: ProductCatalogFacade }]; } });
+        }], ctorParameters: () => [{ type: ProductCatalogFacade }] });
 
 class CatalogFilterHelper {
     buildFilterQuery(filters) {
@@ -1973,10 +1970,10 @@ class CatalogFilterHelper {
         }
         return filterQuery;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogFilterHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogFilterHelper }); }
 }
-CatalogFilterHelper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogFilterHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogFilterHelper.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogFilterHelper });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogFilterHelper, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogFilterHelper, decorators: [{
             type: Injectable
         }] });
 
@@ -2023,10 +2020,10 @@ class CatalogSortHelper {
                 return {};
         }
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogSortHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogSortHelper }); }
 }
-CatalogSortHelper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogSortHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogSortHelper.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogSortHelper });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogSortHelper, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogSortHelper, decorators: [{
             type: Injectable
         }] });
 
@@ -2060,10 +2057,10 @@ class ProductFieldsHelper {
             'group',
         ];
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProductFieldsHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProductFieldsHelper }); }
 }
-ProductFieldsHelper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductFieldsHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ProductFieldsHelper.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductFieldsHelper });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductFieldsHelper, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProductFieldsHelper, decorators: [{
             type: Injectable
         }] });
 
@@ -2082,12 +2079,12 @@ class CatalogOperationsFacade {
     getFieldsHelper() {
         return this.fieldsHelper;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogOperationsFacade, deps: [{ token: CatalogFilterHelper }, { token: CatalogSortHelper }, { token: ProductFieldsHelper }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogOperationsFacade }); }
 }
-CatalogOperationsFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogOperationsFacade, deps: [{ token: CatalogFilterHelper }, { token: CatalogSortHelper }, { token: ProductFieldsHelper }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogOperationsFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogOperationsFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogOperationsFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogOperationsFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogFilterHelper }, { type: CatalogSortHelper }, { type: ProductFieldsHelper }]; } });
+        }], ctorParameters: () => [{ type: CatalogFilterHelper }, { type: CatalogSortHelper }, { type: ProductFieldsHelper }] });
 
 class ProductManagementFacade {
     constructor(brandManager, productServices) {
@@ -2100,15 +2097,15 @@ class ProductManagementFacade {
     getProductServices() {
         return this.productServices;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProductManagementFacade, deps: [{ token: BrandManagerHelper }, { token: 'ProductServicesFacade' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProductManagementFacade }); }
 }
-ProductManagementFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductManagementFacade, deps: [{ token: BrandManagerHelper }, { token: 'ProductServicesFacade' }], target: i0.ɵɵFactoryTarget.Injectable });
-ProductManagementFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductManagementFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ProductManagementFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: ProductManagementFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: BrandManagerHelper }, { type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: BrandManagerHelper }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['ProductServicesFacade']
-                }] }]; } });
+                }] }] });
 
 class CatalogHelpersService {
     constructor(catalogOperations, productManagement) {
@@ -2130,12 +2127,12 @@ class CatalogHelpersService {
     getProductServices() {
         return this.productManagement.getProductServices();
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogHelpersService, deps: [{ token: CatalogOperationsFacade }, { token: ProductManagementFacade }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogHelpersService }); }
 }
-CatalogHelpersService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogHelpersService, deps: [{ token: CatalogOperationsFacade }, { token: ProductManagementFacade }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogHelpersService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogHelpersService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogHelpersService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogHelpersService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogOperationsFacade }, { type: ProductManagementFacade }]; } });
+        }], ctorParameters: () => [{ type: CatalogOperationsFacade }, { type: ProductManagementFacade }] });
 
 class CatalogRepositoryService {
     constructor(productCatalog, productServices) {
@@ -2148,15 +2145,15 @@ class CatalogRepositoryService {
     getProductServices() {
         return this.productServices;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogRepositoryService, deps: [{ token: ProductCatalogFacade }, { token: 'ProductServicesFacade' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogRepositoryService }); }
 }
-CatalogRepositoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogRepositoryService, deps: [{ token: ProductCatalogFacade }, { token: 'ProductServicesFacade' }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogRepositoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogRepositoryService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogRepositoryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogRepositoryService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: ProductCatalogFacade }, { type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: ProductCatalogFacade }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['ProductServicesFacade']
-                }] }]; } });
+                }] }] });
 
 class CatalogService {
     constructor(searchContext, helpersService, shop) {
@@ -2250,15 +2247,15 @@ class CatalogService {
     hasCategory(options) {
         return 'category' in options;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogService, deps: [{ token: CatalogSearchContext }, { token: CatalogHelpersService }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogService }); }
 }
-CatalogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService, deps: [{ token: CatalogSearchContext }, { token: CatalogHelpersService }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable });
-CatalogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CatalogService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CatalogService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: CatalogSearchContext }, { type: CatalogHelpersService }, { type: i3.Shops, decorators: [{
+        }], ctorParameters: () => [{ type: CatalogSearchContext }, { type: CatalogHelpersService }, { type: i3.Shops, decorators: [{
                     type: Inject,
                     args: [DEFAULT_SHOP]
-                }] }]; } });
+                }] }] });
 
 var ProductSorts;
 (function (ProductSorts) {
@@ -2279,10 +2276,11 @@ __decorate([
 ], CategoryWithTree.prototype, "children", void 0);
 
 class WishlistService {
-    constructor(wishlistRepository, shop, logRepository) {
+    constructor(wishlistRepository, productRepository, logRepository, shop) {
         this.wishlistRepository = wishlistRepository;
-        this.shop = shop;
+        this.productRepository = productRepository;
         this.logRepository = logRepository;
+        this.shop = shop;
     }
     initializeServices(catalogServiceFacade, categoryServiceFacade) {
         this.catalogService = catalogServiceFacade.getCatalogService();
@@ -2431,12 +2429,7 @@ class WishlistService {
             .then((res) => res.data.at(0));
     }
     async findProductById(id) {
-        if (!this.catalogService) {
-            throw new Error('CatalogService not initialized. Call initializeServices first.');
-        }
-        const helpersService = this.catalogService['helpersService'];
-        const productServices = helpersService.getProductServices();
-        return productServices.productRepository
+        return this.productRepository
             .find({
             fields: ['id', 'sku', 'EAN', 'name', 'brand'],
             filters: {
@@ -2512,21 +2505,24 @@ class WishlistService {
             productBrand: product.brand,
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: WishlistService, deps: [{ token: 'WishlistRepository' }, { token: 'ProductRepository' }, { token: 'LogRepository' }, { token: DEFAULT_SHOP }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: WishlistService }); }
 }
-WishlistService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: WishlistService, deps: [{ token: 'WishlistRepository' }, { token: DEFAULT_SHOP }, { token: 'LogRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-WishlistService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: WishlistService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: WishlistService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: WishlistService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['WishlistRepository']
-                }] }, { type: i3.Shops, decorators: [{
+                }] }, { type: undefined, decorators: [{
                     type: Inject,
-                    args: [DEFAULT_SHOP]
+                    args: ['ProductRepository']
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['LogRepository']
-                }] }]; } });
+                }] }, { type: i3.Shops, decorators: [{
+                    type: Inject,
+                    args: [DEFAULT_SHOP]
+                }] }] });
 
 class CouponRepositoriesFacade {
     constructor(couponRepository, orderRepository, categoryRepository) {
@@ -2534,12 +2530,12 @@ class CouponRepositoriesFacade {
         this.orderRepository = orderRepository;
         this.categoryRepository = categoryRepository;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CouponRepositoriesFacade, deps: [{ token: 'CouponRepository' }, { token: 'OrderRepository' }, { token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CouponRepositoriesFacade }); }
 }
-CouponRepositoriesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponRepositoriesFacade, deps: [{ token: 'CouponRepository' }, { token: 'OrderRepository' }, { token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-CouponRepositoriesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponRepositoriesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponRepositoriesFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CouponRepositoriesFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['CouponRepository']
                 }] }, { type: undefined, decorators: [{
@@ -2548,7 +2544,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImpor
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['CategoryRepository']
-                }] }]; } });
+                }] }] });
 
 class CouponService {
     constructor(repositoriesFacade, configurationFacade) {
@@ -2779,15 +2775,15 @@ class CouponService {
         }
         return couponUseLimits;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CouponService, deps: [{ token: CouponRepositoriesFacade }, { token: ConfigurationFacade }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CouponService, providedIn: 'root' }); }
 }
-CouponService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponService, deps: [{ token: CouponRepositoriesFacade }, { token: ConfigurationFacade }], target: i0.ɵɵFactoryTarget.Injectable });
-CouponService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CouponService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CouponService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: CouponRepositoriesFacade }, { type: ConfigurationFacade }]; } });
+        }], ctorParameters: () => [{ type: CouponRepositoriesFacade }, { type: ConfigurationFacade }] });
 
 class CheckoutSubscriptionService {
     constructor(checkoutSubscriptionRepository, dataPersistence, couponService) {
@@ -2824,18 +2820,18 @@ class CheckoutSubscriptionService {
         await this.dataPersistence.set('checkoutSubscriptionId', checkout.id).toPromise();
         return checkout;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutSubscriptionService, deps: [{ token: 'CheckoutSubscriptionRepository' }, { token: PERSISTENCE_PROVIDER }, { token: CouponService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutSubscriptionService }); }
 }
-CheckoutSubscriptionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutSubscriptionService, deps: [{ token: 'CheckoutSubscriptionRepository' }, { token: PERSISTENCE_PROVIDER }, { token: CouponService }], target: i0.ɵɵFactoryTarget.Injectable });
-CheckoutSubscriptionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutSubscriptionService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CheckoutSubscriptionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: CheckoutSubscriptionService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['CheckoutSubscriptionRepository']
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [PERSISTENCE_PROVIDER]
-                }] }, { type: CouponService }]; } });
+                }] }, { type: CouponService }] });
 
 class UtilHelper {
     static createSlug(name) {
@@ -2861,12 +2857,12 @@ class HomeShopRepositoriesFacade {
         this.homeRepository = homeRepository;
         this.productRepository = productRepository;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: HomeShopRepositoriesFacade, deps: [{ token: 'CategoryRepository' }, { token: 'HomeRepository' }, { token: 'ProductRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: HomeShopRepositoriesFacade }); }
 }
-HomeShopRepositoriesFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopRepositoriesFacade, deps: [{ token: 'CategoryRepository' }, { token: 'HomeRepository' }, { token: 'ProductRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-HomeShopRepositoriesFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopRepositoriesFacade });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopRepositoriesFacade, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: HomeShopRepositoriesFacade, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['CategoryRepository']
                 }] }, { type: undefined, decorators: [{
@@ -2875,7 +2871,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImpor
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: ['ProductRepository']
-                }] }]; } });
+                }] }] });
 
 class HomeShopService {
     get homeId() {
@@ -2980,12 +2976,118 @@ class HomeShopService {
     get gender() {
         return this.homeId === 'mens_market' ? 'masculino' : undefined;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: HomeShopService, deps: [{ token: HomeShopRepositoriesFacade }, { token: ConfigurationFacade }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: HomeShopService }); }
 }
-HomeShopService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopService, deps: [{ token: HomeShopRepositoriesFacade }, { token: ConfigurationFacade }], target: i0.ɵɵFactoryTarget.Injectable });
-HomeShopService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: HomeShopService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: HomeShopService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: HomeShopRepositoriesFacade }, { type: ConfigurationFacade }]; } });
+        }], ctorParameters: () => [{ type: HomeShopRepositoriesFacade }, { type: ConfigurationFacade }] });
+
+class OrderProductReviewService {
+    constructor(orderRepository, productReviewRepository, variantRepository) {
+        this.orderRepository = orderRepository;
+        this.productReviewRepository = productReviewRepository;
+        this.variantRepository = variantRepository;
+    }
+    async getPendingReviewsByEmail(email) {
+        const products = [];
+        const orders = await this.getOrdersByEmail(email);
+        if (orders.length) {
+            for (const order of orders) {
+                const lineItems = order.lineItems.filter((item) => !item.isGift);
+                for (const item of lineItems) {
+                    const productReview = await this.getProductReview(order, item);
+                    if (productReview?.status != null)
+                        continue;
+                    products.push(this.buildProductReview(order, item, productReview));
+                }
+            }
+        }
+        return products;
+    }
+    async getOrdersByEmail(email) {
+        const { data: orders } = await this.orderRepository.find({
+            filters: {
+                user: {
+                    email: email,
+                },
+                status: OrderStatus.ENTREGUE,
+                createdAt: {
+                    operator: Where.GTE,
+                    value: new Date(2024, 0, 0, 0, 0, 0).getTime(),
+                },
+            },
+            orderBy: {
+                createdAt: 'desc',
+            },
+        });
+        return orders;
+    }
+    async getProductReview(order, item) {
+        const products = [item.id];
+        const isVariant = await this.variantRepository
+            .find({
+            filters: {
+                id: item.id,
+            },
+        })
+            .then((res) => res.data.at(0));
+        if (isVariant)
+            products.push(isVariant.productId);
+        const productReview = await this.productReviewRepository
+            .find({
+            filters: {
+                orderId: { operator: Where.IN, value: [order.id, order.orderNumber].filter(Boolean) },
+                productId: { operator: Where.IN, value: products },
+            },
+        })
+            .then((res) => res.data.at(0));
+        return productReview;
+    }
+    buildProductReview(order, item, review) {
+        return {
+            id: item.id,
+            orderId: order.id,
+            orderNumber: order.orderNumber,
+            isEdition: false,
+            name: item.name,
+            image: item.image,
+            deliveryDate: order.deliveredAt || null,
+            evaluationInAnalysis: review ? true : false,
+            rating: review ? review.rate : null,
+            shopProductSlug: item.slug,
+        };
+    }
+    async createReview(review) {
+        return this.productReviewRepository.create(ProductReview.toInstance({
+            productId: review.productId.toString(),
+            shop: review.shop,
+            rate: review.rate,
+            author: review.author,
+            email: review.email,
+            location: review.location,
+            review: review.comment,
+            title: review.title,
+            personId: review.personId,
+            points: review.points,
+            orderId: review.orderId,
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: OrderProductReviewService, deps: [{ token: 'OrderRepository' }, { token: 'ProductReviewRepository' }, { token: 'VariantRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: OrderProductReviewService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: OrderProductReviewService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i3.OrderFirestoreRepository, decorators: [{
+                    type: Inject,
+                    args: ['OrderRepository']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['ProductReviewRepository']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['VariantRepository']
+                }] }] });
 
 class OrderService {
     constructor(angularFirestore, orderRepository) {
@@ -2999,15 +3101,15 @@ class OrderService {
             .subscribe((doc) => this.orderSubject.next(doc));
         return this.orderSubject;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: OrderService, deps: [{ token: i1$1.Firestore }, { token: 'OrderRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: OrderService }); }
 }
-OrderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderService, deps: [{ token: i1$1.Firestore }, { token: 'OrderRepository' }], target: i0.ɵɵFactoryTarget.Injectable });
-OrderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: OrderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: OrderService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1$1.Firestore }, { type: i3.OrderFirestoreRepository, decorators: [{
+        }], ctorParameters: () => [{ type: i1$1.Firestore }, { type: i3.OrderFirestoreRepository, decorators: [{
                     type: Inject,
                     args: ['OrderRepository']
-                }] }]; } });
+                }] }] });
 
 class AngularConnectModule {
     static initializeApp(defaultShop, options, nameOrConfig) {
@@ -3049,116 +3151,117 @@ class AngularConnectModule {
     static createProviderIfExists(token, value) {
         return isNil(value) ? [] : [{ provide: token, useValue: value }];
     }
-}
-AngularConnectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularConnectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, imports: [i1$3.FirebaseAppModule, i2.AppCheckModule, i3$1.StorageModule, AngularElasticSeachModule,
-        AngularVertexSeachModule,
-        AngularFirebaseAuthModule,
-        AngularFirestoreModule,
-        AngularHasuraGraphQLModule] });
-AngularConnectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, providers: [
-        AuthService,
-        CartService,
-        CatalogService,
-        CategoryService,
-        CheckoutService,
-        CheckoutSubscriptionService,
-        CouponService,
-        HomeShopService,
-        OrderService,
-        WishlistService,
-        ConfigurationFacade,
-        CartServicesFacade,
-        CheckoutRepositoriesFacade,
-        CheckoutDependenciesFacade,
-        CategoryRepositoryFacade,
-        ProductCatalogFacade,
-        CatalogServiceFacade,
-        CategoryServiceFacade,
-        CatalogStrategiesFacade,
-        CatalogOperationsFacade,
-        ProductManagementFacade,
-        {
-            provide: 'ProductServicesFacade',
-            useFactory: (productStockNotificationRepository, categoryRepository, productSearch) => ({
-                productStockNotificationRepository,
-                categoryRepository,
-                productSearch,
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularConnectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.3", ngImport: i0, type: AngularConnectModule, imports: [i1$3.FirebaseAppModule, i2.AppCheckModule, i3$1.StorageModule, AngularElasticSeachModule,
+            AngularVertexSeachModule,
+            AngularFirebaseAuthModule,
+            AngularFirestoreModule,
+            AngularHasuraGraphQLModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularConnectModule, providers: [
+            AuthService,
+            CartService,
+            CatalogService,
+            CategoryService,
+            CheckoutService,
+            CheckoutSubscriptionService,
+            CouponService,
+            HomeShopService,
+            OrderService,
+            WishlistService,
+            ConfigurationFacade,
+            CartServicesFacade,
+            CheckoutRepositoriesFacade,
+            CheckoutDependenciesFacade,
+            CategoryRepositoryFacade,
+            ProductCatalogFacade,
+            CatalogServiceFacade,
+            CategoryServiceFacade,
+            CatalogStrategiesFacade,
+            CatalogOperationsFacade,
+            ProductManagementFacade,
+            {
+                provide: 'ProductServicesFacade',
+                useFactory: (productStockNotificationRepository, categoryRepository, productSearch) => ({
+                    productStockNotificationRepository,
+                    categoryRepository,
+                    productSearch,
+                }),
+                deps: ['ProductStockNotificationRepository', 'CategoryRepository', 'ProductSearch'],
+            },
+            CatalogFilterHelper,
+            CatalogSortHelper,
+            ProductFieldsHelper,
+            BrandManagerHelper,
+            CatalogRepositoryService,
+            CatalogHelpersService,
+            CategorySearchStrategy,
+            TermSearchStrategy,
+            ProfileSearchStrategy,
+            {
+                provide: CatalogSearchContext,
+                useFactory: (categoryStrategy, termStrategy, profileStrategy) => {
+                    return new CatalogSearchContext(categoryStrategy, termStrategy, profileStrategy);
+                },
+                deps: [CategorySearchStrategy, TermSearchStrategy, ProfileSearchStrategy],
+            },
+            {
+                provide: UpdateUserImage,
+                useFactory: (userRepository, fileUploader) => {
+                    return new UpdateUserImage(userRepository, fileUploader);
+                },
+                deps: ['UserRepository', 'FileUploaderService'],
+            },
+            {
+                provide: 'FileUploaderService',
+                useFactory: (storage, baseUrl) => {
+                    return new FirebaseFileUploaderService(storage, baseUrl);
+                },
+                deps: [Storage, STORAGE_BASE_URL],
+            },
+            {
+                provide: 'ProductSearch',
+                useExisting: ProductsVertexSearch,
+            },
+            CouponRepositoriesFacade,
+            HomeShopRepositoriesFacade,
+            OrderProductReviewService,
+        ], imports: [provideFirebaseApp((injector) => {
+                const appName = injector.get(FIREBASE_APP_NAME);
+                try {
+                    const app = appName ? getApp(appName) : getApp();
+                    return app;
+                }
+                catch (error) {
+                    console.warn('Firebase app not found, initializing new app');
+                    if (error instanceof Error)
+                        console.error(error.message);
+                    return initializeApp(injector.get(FIREBASE_OPTIONS), appName);
+                }
             }),
-            deps: ['ProductStockNotificationRepository', 'CategoryRepository', 'ProductSearch'],
-        },
-        CatalogFilterHelper,
-        CatalogSortHelper,
-        ProductFieldsHelper,
-        BrandManagerHelper,
-        CatalogRepositoryService,
-        CatalogHelpersService,
-        CategorySearchStrategy,
-        TermSearchStrategy,
-        ProfileSearchStrategy,
-        {
-            provide: CatalogSearchContext,
-            useFactory: (categoryStrategy, termStrategy, profileStrategy) => {
-                return new CatalogSearchContext(categoryStrategy, termStrategy, profileStrategy);
-            },
-            deps: [CategorySearchStrategy, TermSearchStrategy, ProfileSearchStrategy],
-        },
-        {
-            provide: UpdateUserImage,
-            useFactory: (userRepository, fileUploader) => {
-                return new UpdateUserImage(userRepository, fileUploader);
-            },
-            deps: ['UserRepository', 'FileUploaderService'],
-        },
-        {
-            provide: 'FileUploaderService',
-            useFactory: (storage, baseUrl) => {
-                return new FirebaseFileUploaderService(storage, baseUrl);
-            },
-            deps: [Storage, STORAGE_BASE_URL],
-        },
-        {
-            provide: 'ProductSearch',
-            useExisting: ProductsVertexSearch,
-        },
-        CouponRepositoriesFacade,
-        HomeShopRepositoriesFacade,
-    ], imports: [provideFirebaseApp((injector) => {
-            const appName = injector.get(FIREBASE_APP_NAME);
-            try {
-                const app = appName ? getApp(appName) : getApp();
-                return app;
-            }
-            catch (error) {
-                console.warn('Firebase app not found, initializing new app');
-                if (error instanceof Error)
-                    console.error(error.message);
-                return initializeApp(injector.get(FIREBASE_OPTIONS), appName);
-            }
-        }),
-        provideAppCheck((injector) => {
-            const app = injector.get(FirebaseApp);
-            try {
-                const provider = injector.get(APP_CHECK_PROVIDER);
-                if (provider)
-                    return initializeAppCheck(app, {
-                        provider,
-                        isTokenAutoRefreshEnabled: true,
-                    });
-            }
-            catch (error) {
-                if (error instanceof Error)
-                    console.error(error.message);
-                return;
-            }
-        }),
-        provideStorage((injector) => getStorage(injector.get(FirebaseApp))),
-        AngularElasticSeachModule,
-        AngularVertexSeachModule,
-        AngularFirebaseAuthModule,
-        AngularFirestoreModule,
-        AngularHasuraGraphQLModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AngularConnectModule, decorators: [{
+            provideAppCheck((injector) => {
+                const app = injector.get(FirebaseApp);
+                try {
+                    const provider = injector.get(APP_CHECK_PROVIDER);
+                    if (provider)
+                        return initializeAppCheck(app, {
+                            provider,
+                            isTokenAutoRefreshEnabled: true,
+                        });
+                }
+                catch (error) {
+                    if (error instanceof Error)
+                        console.error(error.message);
+                    return;
+                }
+            }),
+            provideStorage((injector) => getStorage(injector.get(FirebaseApp))),
+            AngularElasticSeachModule,
+            AngularVertexSeachModule,
+            AngularFirebaseAuthModule,
+            AngularFirestoreModule,
+            AngularHasuraGraphQLModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: AngularConnectModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -3265,6 +3368,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImpor
                         },
                         CouponRepositoriesFacade,
                         HomeShopRepositoriesFacade,
+                        OrderProductReviewService,
                     ],
                 }]
         }] });
@@ -3273,5 +3377,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AngularConnectModule, AngularFirebaseAuthModule, AngularFirestoreModule, AngularHasuraGraphQLModule, AuthService, CartService, CatalogService, CategoryService, CategoryWithTree, CheckoutService, CheckoutSubscriptionService, CookieDataPersistence, CouponService, HomeShopService, NewCategoryStructureAdapter, OldCategoryStructureAdapter, OrderService, ProductSorts, UtilHelper, WishlistService };
+export { AngularConnectModule, AngularFirebaseAuthModule, AngularFirestoreModule, AngularHasuraGraphQLModule, AuthService, CartService, CatalogService, CategoryService, CategoryWithTree, CheckoutService, CheckoutSubscriptionService, CookieDataPersistence, CouponService, HomeShopService, NewCategoryStructureAdapter, OldCategoryStructureAdapter, OrderProductReviewService, OrderService, ProductSorts, UtilHelper, WishlistService };
 //# sourceMappingURL=infrab4a-connect-angular.mjs.map