@infrab4a/connect 4.0.0-beta.5 → 4.0.0-beta.50

package/fesm2020/infrab4a-connect.mjs

@@ -3,19 +3,21 @@ import { plainToInstance, instanceToPlain, Expose, Type } from 'class-transforme
 import { __decorate, __metadata } from 'tslib';
 import { parseISO } from 'date-fns';
 export { add, addBusinessDays, addDays, addMonths, addYears, endOfDay, format, formatISO9075, parseISO, startOfDay, sub } from 'date-fns';
-import * as lodash from 'lodash';
-import { get as get$1, isString as isString$1 } from 'lodash';
+import { isNil, isArray, first, last, flatten, compact, get as get$1, isString, each, unset, isObject, isNumber, isDate, set, isEmpty, chunk, isBoolean, isInteger, isNaN as isNaN$1, omit } from 'lodash';
+export { chunk, each, get, isBoolean, isDate, isEmpty, isInteger, isNaN, isNil, isNumber, isObject, isString, now, omit, pick, set, unset } from 'lodash';
+import { Subject } from 'rxjs';
+import { debug } from 'debug';
 import { CustomError } from 'ts-custom-error';
 import axios from 'axios';
 import { collection, getDoc, doc, where, orderBy, getDocs, query, startAfter, startAt, limit, addDoc, setDoc, deleteField, arrayUnion, arrayRemove, deleteDoc, Timestamp } from 'firebase/firestore';
 import { signInWithEmailAndPassword, signInWithPopup, GoogleAuthProvider, signInAnonymously, sendPasswordResetEmail, createUserWithEmailAndPassword, sendEmailVerification } from 'firebase/auth';
 import { mutation, query as query$1 } from 'gql-query-builder';
-import fetch from 'node-fetch';
 
 class BaseModel {
     get identifier() {
         const fields = this.constructor.identifiersFields.filter((field) => field !== 'identifier');
-        return fields.reduce((object, field) => ({ ...object, [field]: this[field] }), {});
+        const data = this;
+        return fields.reduce((object, field) => ({ ...object, [field]: data[field] }), {});
     }
     get identifiersFields() {
         return this.constructor.identifiersFields;
@@ -461,11 +463,437 @@ __decorate([
     __metadata("design:type", Payment)
 ], SubscriptionPayment.prototype, "payment", void 0);
 
-class Address extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
+var DebugNamespaces;
+(function (DebugNamespaces) {
+    DebugNamespaces["ROOT"] = "connect";
+    DebugNamespaces["TRACE"] = "trace";
+    DebugNamespaces["ERROR"] = "error";
+})(DebugNamespaces || (DebugNamespaces = {}));
+const Logger = debug(DebugNamespaces.ROOT);
+
+class ReflectHelper {
+    static get items() {
+        return this._items;
+    }
+    static get keys() {
+        return Object.keys(ReflectHelper.items);
+    }
+    static has(key, target, property) {
+        return (!isNil(key) &&
+            !isNil(ReflectHelper.items[key]) &&
+            (isNil(target) ||
+                (!isNil(ReflectHelper.items[key][target]) &&
+                    (isNil(property) || !isNil(ReflectHelper.items[key][target][String(property)])))));
+    }
+    static get({ key, target, property, own = true }) {
+        try {
+            if (own) {
+                return Reflect.getOwnMetadata(key, target, property) || null;
+            }
+            else {
+                return Reflect.getMetadata(key, target, property) || null;
+            }
+        }
+        catch (_err) {
+            return null;
+        }
+    }
+    static first({ key, target, property, own = true }) {
+        const values = ReflectHelper.get({ key, target, property, own });
+        return isArray(values) ? first(values) : values;
+    }
+    static last({ key, target, property, own = true }) {
+        const values = ReflectHelper.get({ key, target, property, own });
+        return isArray(values) ? last(values) : values;
+    }
+    static set({ key, target, property, value, propertyDescriptor }) {
+        Reflect.defineMetadata(key, value, target, property);
+        ReflectHelper.put({ key, target, property, value, propertyDescriptor });
+    }
+    static add({ key, target, property, value, propertyDescriptor }) {
+        let values = ReflectHelper.get({ key, target, property }) || new Array();
+        if (!Array.isArray(values))
+            values = [values];
+        values.push(value);
+        ReflectHelper.set({ key, target, property, value: values, propertyDescriptor });
+    }
+    static all({ key }) {
+        const items = ReflectHelper.items[key] || {};
+        return flatten(Object.keys(items).map((item) => flatten(this.allFrom(key, items[item]))));
+    }
+    static allFrom(key, target) {
+        return Object.keys(target)
+            .filter((property) => property !== 'object')
+            .map((property) => this.allValuesFrom(key, target, property));
+    }
+    static allValuesFrom(key, target, property) {
+        const values = target[property];
+        let value = values.value;
+        const propertyDescriptor = values.propertyDescriptor;
+        if (!isArray(value))
+            value = [value];
+        return flatten(value.map((val) => {
+            return {
+                key,
+                target: target.object,
+                property,
+                value: val,
+                propertyDescriptor,
+            };
+        }));
+    }
+    static delete({ key, target, property }) {
+        Reflect.deleteMetadata(key, target, property);
+        return ReflectHelper.remove(key, target, property);
+    }
+    static clear(key) {
+        if (!key) {
+            ReflectHelper.keys.forEach((storedKey) => {
+                ReflectHelper.clear(storedKey);
+            });
+        }
+        else {
+            if (ReflectHelper.keys.includes(key)) {
+                Object.values(ReflectHelper.items[key]).forEach((target) => {
+                    if (ReflectHelper.has(key, target)) {
+                        Object.values(ReflectHelper.items[key][target.toString()]).forEach((property) => {
+                            ReflectHelper.delete({
+                                key,
+                                target: target.object,
+                                property: String(property),
+                            });
+                            ReflectHelper.remove(key, target, String(property));
+                        });
+                    }
+                    ReflectHelper.delete({ key, target: target.object });
+                    ReflectHelper.remove(key, target);
+                });
+            }
+        }
+    }
+    static getType({ target, propertyKey }) {
+        return Reflect.getMetadata('design:type', target, propertyKey);
+    }
+    static getReturntype({ target, propertyKey }) {
+        return Reflect.getMetadata('design:returntype', target, propertyKey);
+    }
+    static getAllMethods(target) {
+        const props = [];
+        let obj = target;
+        do {
+            props.push(...Object.getOwnPropertyNames(obj));
+        } while ((obj = Object.getPrototypeOf(obj)));
+        return props.sort().filter((e, i, arr) => {
+            if ([
+                '__defineGetter__',
+                '__defineSetter__',
+                '__lookupGetter__',
+                '__lookupSetter__',
+                'constructor',
+                'hasOwnProperty',
+                'isPrototypeOf',
+                'propertyIsEnumerable',
+                'toLocaleString',
+                'toString',
+                'valueOf',
+            ].includes(e))
+                return false;
+            if (e != arr[i + 1] && typeof target[e] === 'function')
+                return true;
+        });
+    }
+    static put({ key, target, property, value, propertyDescriptor }) {
+        const index = target.constructor.name;
+        ReflectHelper.items[key] = ReflectHelper.items[key] || {};
+        ReflectHelper.items[key][index] = ReflectHelper.items[key][index] || {};
+        ReflectHelper.items[key][index].object = target;
+        if (isNil(property)) {
+            ReflectHelper.items[key][index].value = {
+                value,
+                propertyDescriptor,
+            };
+        }
+        else {
+            ReflectHelper.items[key][index][String(property)] = ReflectHelper.items[key][index][String(property)] || {};
+            ReflectHelper.items[key][index][String(property)] = {
+                value,
+                propertyDescriptor,
+            };
+        }
+    }
+    static remove(key, target, property) {
+        if (ReflectHelper.has(key, target, property))
+            return delete ReflectHelper.items[key][target][String(property)];
+        else if (ReflectHelper.has(key, target))
+            return delete ReflectHelper.items[key][target];
+        else if (ReflectHelper.has(key))
+            return delete ReflectHelper.items[key];
+        else
+            return false;
     }
 }
+ReflectHelper._items = {};
+
+class DebugDecoratorHelper {
+    static set(target, options) {
+        ReflectHelper.add({
+            key: DebugDecoratorHelper.DebugNamingMetadataKey,
+            target,
+            value: options,
+        });
+    }
+    static get(target) {
+        return ReflectHelper.first({
+            key: DebugDecoratorHelper.DebugNamingMetadataKey,
+            target,
+        });
+    }
+}
+DebugDecoratorHelper.DebugNamingMetadataKey = 'model:naming:decorator';
+
+class ClassNameHelper {
+    static get(clazz) {
+        if (!clazz)
+            return null;
+        const prototype = Object.getPrototypeOf(clazz);
+        const names = compact([
+            get$1(clazz, 'constructor.name'),
+            get$1(prototype, 'constructor.name'),
+            get$1(prototype, '__proto__.constructor.name'),
+        ]);
+        return names.find((name) => name !== 'class_1');
+    }
+}
+
+const isDebuggable = (object) => {
+    return 'debug' in object;
+};
+class DebugHelper {
+    constructor(...namespace) {
+        this.namespaces = new Set();
+        this.push(...namespace);
+    }
+    static namespacesFor(target) {
+        if (isNil(target))
+            return [];
+        const decorator = DebugDecoratorHelper.get(Object.getPrototypeOf(target));
+        const namespaces = get$1(decorator, 'namespaces', []);
+        const name = get$1(decorator, 'name', ClassNameHelper.get(target));
+        return [...namespaces, name];
+    }
+    static as(...namespaces) {
+        return new DebugHelper(...namespaces);
+    }
+    static for(target, ...namespaces) {
+        const targetNamespaces = this.namespacesFor(target);
+        return new DebugHelper(...targetNamespaces, ...namespaces);
+    }
+    static from(target, ...namespaces) {
+        if (this.isDebuggable(target)) {
+            const debug = target.debug;
+            if (namespaces)
+                debug.push(...namespaces);
+            return debug;
+        }
+        return DebugHelper.for(target, ...namespaces);
+    }
+    static clonedFrom(target, ...namespaces) {
+        if (this.isDebuggable(target)) {
+            namespaces.push(...target.debug.entries);
+        }
+        else if (!isNil(target)) {
+            namespaces.push(...this.namespacesFor(target));
+        }
+        return DebugHelper.for(target, ...namespaces);
+    }
+    static clone(target, ...namespaces) {
+        let original;
+        if (this.isDebuggable(target)) {
+            original = target.debug;
+            namespaces.push(...original.entries);
+        }
+        return {
+            original,
+            debug: DebugHelper.for(target, ...namespaces),
+        };
+    }
+    static replace(target, attrs) {
+        if (this.isDebuggable(target))
+            target.debug = attrs.with;
+    }
+    static mock(target, ...namespaces) {
+        const { original, debug } = DebugHelper.clone(target, ...namespaces);
+        DebugHelper.replace(target, { with: debug });
+        return { original, debug };
+    }
+    get entries() {
+        return Array.from(get$1(this, 'namespaces', []));
+    }
+    get namespace() {
+        return compact(flatten(this.entries)).join(':');
+    }
+    log(message, ...args) {
+        this.logger(JSON.stringify(message), ...args.map((element) => JSON.stringify(element)));
+        DebugHelper.logs$.next({ namespace: this.namespace, message, args });
+        return this;
+    }
+    trace(message, ...args) {
+        this.logger.extend(DebugNamespaces.TRACE)(message, ...args);
+        DebugHelper.traces$.next({ namespace: this.namespace, message, args });
+        return this;
+    }
+    error(error, ...args) {
+        this.logger.extend(DebugNamespaces.ERROR)(JSON.stringify(error), ...args.map((element) => JSON.stringify(element)));
+        DebugHelper.errors$.next({ namespace: this.namespace, error, args });
+        return this;
+    }
+    build() {
+        this.logger = Logger;
+        this.tracer = Logger;
+        this.err = Logger;
+        this.entries.forEach((namespace) => {
+            this.logger = this.logger.extend(namespace);
+            this.tracer = this.tracer.extend(namespace);
+            this.err = this.err.extend(namespace);
+        });
+        return this;
+    }
+    with(...namespace) {
+        return new DebugHelper(...this.entries, ...namespace);
+    }
+    push(...namespace) {
+        if (namespace) {
+            namespace.filter((item) => Boolean(item)).forEach((item) => this.namespaces.add(item));
+        }
+        return this.build();
+    }
+    unshift(...namespace) {
+        if (namespace) {
+            return this.reset(...namespace, ...this.entries);
+        }
+        return this;
+    }
+    reset(...namespace) {
+        this.namespaces = new Set(flatten(compact(namespace)));
+        return this.build();
+    }
+    startWith(...namespace) {
+        const current = this.namespaces;
+        this.namespaces = new Set(flatten([compact(namespace), ...current]));
+        return this.build();
+    }
+    shift() {
+        const list = this.entries;
+        list.shift();
+        return this.reset(...list);
+    }
+    pop() {
+        const list = this.entries;
+        list.pop();
+        return this.reset(...list);
+    }
+    clear() {
+        return this.reset();
+    }
+    remove(...namespace) {
+        if (namespace) {
+            namespace.filter((item) => Boolean(item)).forEach((item) => this.namespaces.delete(item));
+        }
+        return this.build();
+    }
+    puts(...args) {
+        return [`[${this.namespace}]`, ...args].join(' ');
+    }
+}
+DebugHelper.logs$ = new Subject();
+DebugHelper.traces$ = new Subject();
+DebugHelper.errors$ = new Subject();
+DebugHelper.isDebuggable = isDebuggable;
+
+function Debug(opts) {
+    return function (target) {
+        DebugDecoratorHelper.set(target.prototype, opts);
+    };
+}
+
+const ASYNC_IDENTIFIER = 'async';
+function Log(options = {}) {
+    return Trace({ level: 'log', ...options });
+}
+function Trace(options = {}) {
+    return function (target, propertyKey, propertyDescriptor) {
+        const method = propertyDescriptor.value;
+        const isPromise = method.toString().includes(ASYNC_IDENTIFIER);
+        const args = {
+            options,
+            method,
+            target,
+            propertyKey,
+            propertyDescriptor,
+        };
+        propertyDescriptor.value = isPromise ? promiseTracer(args) : functionTracer(args);
+        return propertyDescriptor;
+    };
+}
+const traceCall = function ({ target, propertyKey, propertyDescriptor, args }) {
+    if (!target.debug)
+        target.debug = DebugHelper.for(target, propertyKey);
+    return target.debug.push(propertyKey).trace('called', { target, propertyKey, propertyDescriptor, args });
+};
+const promiseTracer = function ({ options, method, propertyKey, propertyDescriptor }) {
+    return function (...args) {
+        return new Promise((resolve, reject) => {
+            const debug = traceCall({ target: this, propertyDescriptor, propertyKey, args });
+            if (get$1(options, 'level', '') === 'log') {
+                debug.with('params').log(args);
+            }
+            return method
+                .apply(this, args)
+                .then((result) => {
+                if (options.callbackFn) {
+                    options.callbackFn({ target: this, result, args, namespace: [propertyKey] });
+                }
+                if (get$1(options, 'level', '') === 'log') {
+                    debug.with('returns').log(result === undefined ? 'void' : result);
+                }
+                return resolve(result);
+            })
+                .catch((error) => {
+                debug.error(error, ...args);
+                debug.with('stack').error(error.stack).pop();
+                return reject(error);
+            })
+                .finally(() => {
+                return debug.trace('finally', { args }).pop();
+            });
+        });
+    };
+};
+const functionTracer = function ({ options, target, method, propertyKey, propertyDescriptor, }) {
+    return function (...args) {
+        const debug = traceCall({ target: this || target, propertyDescriptor, propertyKey, args });
+        if (get$1(options, 'level', '') === 'log') {
+            debug.with('params').log(args);
+        }
+        let result;
+        try {
+            result = method.apply(this, args);
+            if (options.callbackFn)
+                options.callbackFn({ target: this, result, args, namespace: [propertyKey] });
+            if (get$1(options, 'level', '') === 'log') {
+                debug.with('returns').log(result === undefined ? 'void' : result);
+            }
+            return result;
+        }
+        catch (error) {
+            debug.error(error, ...args).pop();
+            throw error;
+        }
+        finally {
+            debug.trace('finally', { args }).pop();
+        }
+    };
+};
 
 const get = (object, path, defaultValue) => get$1(object, path, defaultValue);
 
@@ -473,7 +901,7 @@ function is(value) {
     return value;
 }
 
-const isUUID = (value) => isString$1(value) && /[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}/.test(value);
+const isUUID = (value) => isString(value) && /[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}/.test(value);
 
 class Base {
     constructor(...args) {
@@ -482,7 +910,7 @@ class Base {
 }
 
 const parseDateTime = (value) => {
-    if (!isString$1(value))
+    if (!isString(value))
         return value;
     if (!/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.test(value) &&
         !/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T\d{2}:\d{2}:\d{2}/.test(value))
@@ -493,8 +921,6 @@ const parseDateTime = (value) => {
     return date;
 };
 
-const { chunk, isBoolean, isDate, isEmpty, isInteger, isNaN: isNaN$1, isNil, isNumber, isObject, isString, now, omit, pick, set, } = lodash;
-
 var CheckoutTypes;
 (function (CheckoutTypes) {
     CheckoutTypes[CheckoutTypes["ECOMMERCE"] = 1] = "ECOMMERCE";
@@ -539,26 +965,28 @@ class Coupon extends BaseModel {
     static createCoupon(userId) {
         return this.toInstance({
             nickname: `${Date.now()}`,
-            type: CouponTypes.ABSOLUTE,
             checkoutType: CheckoutTypes.ECOMMERCE,
-            discount: 30,
+            discount: {
+                subscriber: {
+                    type: CouponTypes.ABSOLUTE,
+                    value: 10,
+                },
+                non_subscriber: {
+                    type: CouponTypes.ABSOLUTE,
+                    value: 10,
+                },
+                subscription: {
+                    type: CouponTypes.ABSOLUTE,
+                    value: 10,
+                },
+            },
             user: userId,
-            useLimit: 1,
-            useLimitPerUser: true,
             createdAt: new Date(Date.now()),
             beginAt: new Date(Date.now()),
             expiresIn: new Date(Date.now() + COUPON_EXPIRATION),
         });
     }
 }
-__decorate([
-    Expose({ name: 'checkout_type' }),
-    __metadata("design:type", Number)
-], Coupon.prototype, "checkoutType", void 0);
-__decorate([
-    Expose({ name: 'exclusivity_type' }),
-    __metadata("design:type", Number)
-], Coupon.prototype, "exclusivityType", void 0);
 
 class SubscriptionPlan extends BaseModel {
     static get identifiersFields() {
@@ -598,6 +1026,18 @@ __decorate([
     __metadata("design:type", BeautyProfile)
 ], User.prototype, "beautyProfile", void 0);
 
+class Address extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class UserAddress extends Address {
+    static get identifiersFields() {
+        return ['id', 'userId'];
+    }
+}
+
 class Subscription extends BaseModel {
     static get identifiersFields() {
         return ['id'];
@@ -612,12 +1052,12 @@ __decorate([
     __metadata("design:type", SubscriptionPlan)
 ], Subscription.prototype, "subscriptionPlan", void 0);
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], Subscription.prototype, "shippingAddress", void 0);
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], Subscription.prototype, "billingAddress", void 0);
 __decorate([
     Type(() => Coupon),
@@ -632,12 +1072,6 @@ __decorate([
     __metadata("design:type", Array)
 ], Subscription.prototype, "payment", void 0);
 
-class UserAddress extends Address {
-    static get identifiersFields() {
-        return ['id', 'userId'];
-    }
-}
-
 class UserPaymentMethod extends BaseModel {
     static get identifiersFields() {
         return ['id', 'userId'];
@@ -669,7 +1103,7 @@ class Authentication {
     async signIn({ email, password }, signInMethod) {
         const method = this.getServiceByMethod(signInMethod);
         const userAuth = await this.authService[method]({ email, password });
-        const user = this.userRepository.get(userAuth);
+        const user = this.userRepository.get({ id: userAuth.id });
         if (!isNil(user))
             return user;
         if (/^.+@b4a.com.br$/.test(userAuth.email))
@@ -762,14 +1196,123 @@ class RecoveryPassword {
     }
 }
 
-class Category extends BaseModel {
-    identifierFields() {
+class Filter extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class CategoryBase extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+__decorate([
+    Type(() => CategoryBase),
+    __metadata("design:type", CategoryBase)
+], CategoryBase.prototype, "parent", void 0);
+__decorate([
+    Type(() => Filter),
+    __metadata("design:type", Array)
+], CategoryBase.prototype, "filters", void 0);
+
+class CategoryForProduct extends CategoryBase {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class ProductBase extends BaseModel {
+    get evaluation() {
+        return {
+            reviews: this.reviews,
+            count: this.reviewsTotal,
+            rating: this.rate,
+        };
+    }
+    set evaluation(evaluation) {
+        if (!evaluation) {
+            this.reviews = null;
+            this.reviewsTotal = null;
+            this.rate = null;
+            return;
+        }
+        this.reviews = evaluation.reviews || this.reviews;
+        this.reviewsTotal = evaluation.count || this.reviewsTotal;
+        this.rate = evaluation.rating || this.rate;
+    }
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class ProductForKit extends ProductBase {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+__decorate([
+    Type(() => CategoryForProduct),
+    __metadata("design:type", CategoryForProduct)
+], ProductForKit.prototype, "category", void 0);
+
+class KitProduct extends BaseModel {
+    static get identifiersFields() {
+        return ['productId', 'kitProductId'];
+    }
+}
+__decorate([
+    Type(() => ProductForKit),
+    __metadata("design:type", ProductForKit)
+], KitProduct.prototype, "kit", void 0);
+__decorate([
+    Type(() => ProductForKit),
+    __metadata("design:type", ProductForKit)
+], KitProduct.prototype, "product", void 0);
+
+class ProductForCategory extends ProductBase {
+    static get identifiersFields() {
         return ['id'];
     }
+}
+__decorate([
+    Type(() => KitProduct),
+    __metadata("design:type", Array)
+], ProductForCategory.prototype, "kitProducts", void 0);
+
+class Category extends CategoryBase {
     static get identifiersFields() {
         return ['id'];
     }
 }
+__decorate([
+    Type(() => ProductForCategory),
+    __metadata("design:type", Array)
+], Category.prototype, "childrenProducts", void 0);
+
+class CategoryCollectionChildren extends BaseModel {
+    static get identifiersFields() {
+        return ['collectionId', 'categoryId'];
+    }
+}
+__decorate([
+    Type(() => CategoryCollectionChildren),
+    __metadata("design:type", CategoryCollectionChildren)
+], CategoryCollectionChildren.prototype, "parent", void 0);
+
+class CategoryFilter extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+__decorate([
+    Type(() => Filter),
+    __metadata("design:type", Filter)
+], CategoryFilter.prototype, "filter", void 0);
+__decorate([
+    Type(() => Category),
+    __metadata("design:type", Category)
+], CategoryFilter.prototype, "category", void 0);
 
 var GenderDestination;
 (function (GenderDestination) {
@@ -786,53 +1329,59 @@ var Shops;
     Shops["ALL"] = "ALL";
 })(Shops || (Shops = {}));
 
-class Product extends BaseModel {
-    identifierFields() {
+class FilterOption extends BaseModel {
+    static get identifiersFields() {
         return ['id'];
     }
+}
+
+class Product extends ProductBase {
     static get identifiersFields() {
         return ['id'];
     }
 }
+__decorate([
+    Type(() => CategoryForProduct),
+    __metadata("design:type", CategoryForProduct)
+], Product.prototype, "category", void 0);
 __decorate([
     Type(() => KitProduct),
     __metadata("design:type", Array)
 ], Product.prototype, "kitProducts", void 0);
 
-class KitProduct extends BaseModel {
+class Variant extends BaseModel {
     static get identifiersFields() {
-        return ['productId', 'kitProducId'];
+        return ['id', 'productId'];
     }
 }
-__decorate([
-    Type(() => Product),
-    __metadata("design:type", Product)
-], KitProduct.prototype, "kit", void 0);
-__decorate([
-    Type(() => Product),
-    __metadata("design:type", Product)
-], KitProduct.prototype, "product", void 0);
 
-class Variant extends BaseModel {
-    identifierFields() {
+class Wishlist extends Category {
+    static get identifiersFields() {
         return ['id'];
     }
+}
+
+class Buy2Win extends BaseModel {
     static get identifiersFields() {
-        return ['id', 'productId'];
+        return ['id'];
     }
 }
+__decorate([
+    Type(() => Category),
+    __metadata("design:type", Array)
+], Buy2Win.prototype, "categories", void 0);
 
-var OrderStatus;
-(function (OrderStatus) {
-    OrderStatus["AGUARDANDO_PAGAMENTO"] = "Aguardando pagamento";
-    OrderStatus["EM_PREPARO"] = "Preparando pedido";
-    OrderStatus["NF_EMITIDA"] = "Nota Fiscal Emitida";
-    OrderStatus["AGUARDANDO_ENVIO"] = "Aguardando Transaportadora";
-    OrderStatus["ENVIADO"] = "Enviado";
-    OrderStatus["ENTREGUE"] = "Entregue";
-    OrderStatus["CANCELADO"] = "Cancelado";
-    OrderStatus["CREDIT_CARD"] = "credit_card";
-})(OrderStatus || (OrderStatus = {}));
+class CampaignDashboard extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class CampaignHashtag extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
 
 class LineItem extends Product {
 }
@@ -857,12 +1406,12 @@ __decorate([
     __metadata("design:type", User)
 ], Checkout.prototype, "user", void 0);
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], Checkout.prototype, "shippingAddress", void 0);
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], Checkout.prototype, "billingAddress", void 0);
 __decorate([
     Type(() => ShippingMethod),
@@ -873,6 +1422,18 @@ __decorate([
     __metadata("design:type", Coupon)
 ], Checkout.prototype, "coupon", void 0);
 
+var OrderStatus;
+(function (OrderStatus) {
+    OrderStatus["AGUARDANDO_PAGAMENTO"] = "Aguardando pagamento";
+    OrderStatus["EM_PREPARO"] = "Preparando pedido";
+    OrderStatus["NF_EMITIDA"] = "Nota Fiscal Emitida";
+    OrderStatus["AGUARDANDO_ENVIO"] = "Aguardando Transaportadora";
+    OrderStatus["ENVIADO"] = "Enviado";
+    OrderStatus["ENTREGUE"] = "Entregue";
+    OrderStatus["CANCELADO"] = "Cancelado";
+    OrderStatus["CREDIT_CARD"] = "credit_card";
+})(OrderStatus || (OrderStatus = {}));
+
 class Order extends Checkout {
 }
 __decorate([
@@ -886,12 +1447,12 @@ class CheckoutSubscription extends BaseModel {
     }
 }
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], CheckoutSubscription.prototype, "shippingAddress", void 0);
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], CheckoutSubscription.prototype, "billingAddress", void 0);
 __decorate([
     Type(() => SubscriptionPlan),
@@ -902,15 +1463,19 @@ __decorate([
     __metadata("design:type", Coupon)
 ], CheckoutSubscription.prototype, "coupon", void 0);
 
-class Buy2Win extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
+class RoundProductPricesHelper {
+    static roundProductPrices(product) {
+        product.price.price = Number(product.price.price.toFixed(2));
+        product.price.fullPrice = Number(product.price.fullPrice.toFixed(2));
+        if (product.price.subscriberPrice) {
+            product.price.subscriberPrice = Number(product.price.subscriberPrice.toFixed(2));
+        }
+        if (product instanceof LineItem && product.pricePaid) {
+            product.pricePaid = Number(product.pricePaid.toFixed(2));
+        }
+        return product;
     }
 }
-__decorate([
-    Type(() => Category),
-    __metadata("design:type", Array)
-], Buy2Win.prototype, "categories", void 0);
 
 var FilterType;
 (function (FilterType) {
@@ -1011,6 +1576,12 @@ class ShopMenu extends BaseModel {
     }
 }
 
+class ShopSettings extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
 class InvalidArgumentError extends CustomError {
     constructor(message) {
         super(message);
@@ -1041,12 +1612,16 @@ class AxiosAdapter {
     constructor(config) {
         this.config = config;
     }
-    async get(index) {
+    async get(index, id) {
         try {
             const { data } = await axios({
-                url: `${this.config.url}/${index}`,
+                url: `${this.config.url}/${index}/_doc/${id}`,
                 method: 'GET',
-                headers: { Authorization: `Basic ${this.config.credential}` },
+                responseType: 'json',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `ApiKey ${this.config.credential}`,
+                },
             });
             return data._source;
         }
@@ -1058,9 +1633,14 @@ class AxiosAdapter {
     }
     async query(index, query) {
         const { data } = await axios({
-            url: `${this.config.url}/${index}`,
+            url: `${this.config.url}/${index}/_search`,
             method: 'POST',
-            headers: { Authorization: `Basic ${this.config.credential}` },
+            responseType: 'json',
+            headers: {
+                Accept: 'application/vnd.elasticsearch+json;compatible-with=7',
+                'Content-Type': 'application/vnd.elasticsearch+json;compatible-with=7',
+                Authorization: `ApiKey ${this.config.credential}`,
+            },
             data: query,
         });
         return {
@@ -1070,17 +1650,25 @@ class AxiosAdapter {
     }
     async save(index, data) {
         await axios({
-            url: `${this.config.url}/${index}`,
+            url: `${this.config.url}/${index}/_doc`,
+            method: 'POST',
+            headers: { Authorization: `ApiKey ${this.config.credential}` },
+            data,
+        });
+    }
+    async update(index, id, data) {
+        await axios({
+            url: `${this.config.url}/${index}/_update/${id}`,
             method: 'PUT',
-            headers: { Authorization: `Basic ${this.config.credential}` },
+            headers: { Authorization: `ApiKey ${this.config.credential}` },
             data,
         });
     }
-    async delete(index) {
+    async delete(index, id) {
         await axios({
-            url: `${this.config.url}/${index}`,
+            url: `${this.config.url}/${index}/_doc/${id}`,
             method: 'DELETE',
-            headers: { Authorization: `Basic ${this.config.credential}` },
+            headers: { Authorization: `ApiKey ${this.config.credential}` },
         });
     }
 }
@@ -1088,13 +1676,16 @@ class AxiosAdapter {
 class ProductsIndex {
     constructor(adapter) {
         this.adapter = adapter;
+        this.index = `products`;
     }
-    async get(id) {
-        const data = await this.adapter.get(`products/_doc/${id}`);
+    async getById(id) {
+        const data = await this.adapter.get(this.index, id);
         return Product.toInstance(data);
     }
-    async findById(ids, options) {
+    async search(searchTerm, total, shop) {
+        const size = total || 9;
         const fields = [
+            'EAN',
             'brand',
             'id',
             'images',
@@ -1105,73 +1696,82 @@ class ProductsIndex {
             'stock',
             'slug',
             'reviews',
-            'pricePaid',
-            'isGift',
-            'stock',
-            'weight',
-            'tags',
             'hasVariants',
-            'type',
+            'rate',
         ];
-        const { hits } = await this.adapter.query('products/_search', {
+        const filter = [{ term: { published: true } }];
+        if (size > 9) {
+            fields.push(...['pricePaid', 'isGift', 'stock', 'weight', 'tags']);
+        }
+        else {
+            filter.push({ term: { tags: shop == Shops.GLAMSHOP ? 'feminino' : 'masculino' } });
+        }
+        const search = await this.adapter.query(this.index, {
+            size,
             _source: fields,
             query: {
                 bool: {
-                    filter: [
-                        {
-                            terms: {
-                                _id: ids,
-                            },
+                    must: {
+                        multi_match: {
+                            query: `${searchTerm}`,
+                            type: 'bool_prefix',
+                            fields: [
+                                'name',
+                                'name.folded',
+                                'name.search',
+                                'description',
+                                'description.search',
+                                'description.folded',
+                                'brand',
+                                'brand.search',
+                                'brand.folded',
+                            ],
+                            fuzziness: 2,
                         },
-                        {
-                            term: {
-                                published: true,
+                    },
+                    should: {
+                        match_phrase_prefix: {
+                            'name.search': {
+                                query: `${searchTerm}`,
+                                slop: 10,
                             },
                         },
-                        ...(options?.hasStock
-                            ? [
-                                {
-                                    range: {
-                                        'stock.quantity': {
-                                            gt: 0,
-                                        },
-                                    },
-                                },
-                            ]
-                            : []),
-                    ],
+                    },
+                    filter,
                 },
             },
-            ...(options?.size ? { size: options?.size } : {}),
         });
-        return hits.map((hit) => Product.toInstance(hit._source));
+        search.hits = search.hits
+            .filter((e) => e._source.name !== '')
+            .map((hit) => {
+            RoundProductPricesHelper.roundProductPrices(hit._source);
+            return hit;
+        });
+        return search;
     }
     async save(product) {
-        delete product.createdAt;
-        delete product.updatedAt;
-        delete product.kitProducts;
         try {
-            if (!product.firestoreId)
-                throw new Error('Is not a product from firestore');
-            await this.get(product.firestoreId);
-            await this.adapter.save(`products/_doc/${product.firestoreId}`, product.toPlain());
+            const { createdAt, updatedAt, kitProducts, ...data } = product;
+            this.adapter.save(this.index, data);
         }
         catch (error) {
-            if (!(error instanceof Error))
-                throw error;
-            console.error(error.message);
-            await this.adapter.save(`products/_doc/${product.id}`, product.toPlain());
+            console.error(error);
         }
     }
-    async delete(product) {
-        if (!product.firestoreId)
-            return;
+    async update(product) {
+        try {
+            await this.adapter.update(this.index, product.id, product);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    async delete(id) {
         try {
-            await this.get(product.firestoreId);
-            await this.adapter.delete(`products/_doc/${product.firestoreId}`);
+            await this.adapter.delete(this.index, id);
         }
         catch (error) {
-            await this.adapter.delete(`products/_doc/${product.id}`);
+            console.error(error);
         }
     }
 }
@@ -1201,17 +1801,39 @@ const withFirestore = (MixinBase) => {
                     : bindDate(data[key], key),
         }), {});
     };
+    const omitByRecursivelyInPlace = (value, iteratee) => {
+        each(value, (v, k) => {
+            if (iteratee(v, k)) {
+                unset(value, k);
+            }
+            else if (isObject(v)) {
+                omitByRecursivelyInPlace(v, iteratee);
+            }
+        });
+        return value;
+    };
     return class extends MixinBase {
-        constructor() {
-            super(...arguments);
+        constructor(...params) {
+            super(...params);
+            this.fields = {};
+            this.interceptors = {};
             this.collectionName = '';
+            const options = params[0];
+            this.firestore = options.firestore;
+            this.collectionName = options.collectionName;
+            this.model = options.model;
+            this.fields = options.fields;
+            this.interceptors = options.interceptors;
         }
         collection(path) {
             return collection(this.firestore, path || this.collectionName).withConverter(this.buildModelInstance());
         }
         buildModelInstance() {
             return {
-                toFirestore: (data) => (data?.toPlain ? data.toPlain() : data),
+                toFirestore: (data) => {
+                    const plain = data?.toPlain ? data.toPlain() : data;
+                    return omitByRecursivelyInPlace(plain, (value) => value === undefined);
+                },
                 fromFirestore: (snap) => {
                     const data = snap.data();
                     let bindedData = null;
@@ -1251,11 +1873,14 @@ const withHelpers = (MixinBase) => {
 const withGetFirestore = (MixinBase) => {
     return class GetFirestore extends MixinBase {
         async get(identifiers) {
-            const docRef = await getDoc(doc(await this.collection(this.buildCollectionPathForGet(identifiers)), Object.values(identifiers).shift().toString()));
+            const instance = this.model.toInstance(this.model.identifiersFields.reduce((acc, field) => ({ ...acc, [field]: identifiers[field] }), {}));
+            const intercepted = await this.interceptors?.request?.({ instance });
+            const builded = intercepted?.instance || instance;
+            const docRef = await getDoc(doc(await this.collection(this.buildCollectionPathForGet(identifiers)), Object.values(builded.identifier).shift().toString()));
             const data = docRef.data();
             if (isNil(data))
                 throw new NotFoundError(`Document ${JSON.stringify(identifiers)} not found`);
-            return data;
+            return this.interceptors?.response?.(data, intercepted) || data;
         }
         buildCollectionPathForGet(identifiers) {
             return this.isSubCollection(this)
@@ -1292,7 +1917,7 @@ const withFindFirestore = (MixinBase) => {
             ], []);
             this.buildWhereSentence = (fieldName, options) => {
                 if (this.isSubCollection(this) && fieldName === this.parentIdField)
-                    [];
+                    return [];
                 const value = options?.value || options;
                 const object = {};
                 set(object, fieldName, value);
@@ -1336,8 +1961,11 @@ const withFindFirestore = (MixinBase) => {
                 return Object.keys(fieldsToOrderBy).map((fieldName) => orderBy(fieldName, fieldsToOrderBy[fieldName]));
             };
         }
-        async find({ filters, limits, orderBy, } = {}) {
-            const collection = this.collection(this.buildCollectionPathForFind(filters));
+        async find(find = {}) {
+            const collection = this.collection(this.buildCollectionPathForFind(find.filters));
+            const enableCount = find?.options?.enableCount ?? true;
+            const intercepted = await this.interceptors?.request?.({ find });
+            const { filters, limits, orderBy } = intercepted.find || find;
             const queries = this.makeFirestoreWhere(filters || {});
             const ordination = this.makeFirestoreOrderBy(filters, orderBy);
             const offsets = await this.defineLimits(filters, limits);
@@ -1345,8 +1973,8 @@ const withFindFirestore = (MixinBase) => {
             const docs = await getDocs(query(collection, ...queryArgumments));
             const data = docs.docs.map((doc) => doc.data());
             return {
-                data,
-                count: this.calculateCount(data, limits),
+                data: (await this.interceptors?.response?.(data, intercepted)) || data,
+                count: enableCount ? this.calculateCount(data, limits) : Infinity,
             };
         }
         buildCollectionPathForFind(filters) {
@@ -1360,7 +1988,7 @@ const withFindFirestore = (MixinBase) => {
             const queries = [];
             if (limits?.offset) {
                 if (this.model.isModel(limits.offset))
-                    queries.push(startAfter(await getDoc(doc(this.collection(this.buildCollectionPathForFind(filters)), limits.offset.identifier.shift()))));
+                    queries.push(startAfter(await getDoc(doc(this.collection(this.buildCollectionPathForFind(filters)), Object.values(limits.offset.identifier).shift()?.toString()))));
                 else if (isNumber(limits.offset) || isString(limits.offset))
                     queries.push(startAt(limits.offset));
             }
@@ -1381,12 +2009,16 @@ const withFindFirestore = (MixinBase) => {
 const withCreateFirestore = (MixinBase) => {
     return class CreateFirestore extends MixinBase {
         async create(data) {
-            const docRef = await this.save(this.model.toInstance(data));
+            const instance = this.model.toInstance(data);
+            const intercepted = await this.interceptors?.request?.({ instance });
+            const builded = intercepted?.instance || instance;
+            const docRef = await this.save(builded);
             const doc = await getDoc(docRef);
-            return doc.data();
+            const docBuilded = (await this.interceptors?.response?.(doc.data(), intercepted)) || doc.data();
+            return docBuilded;
         }
         async save(data) {
-            const id = data.identifier[data.identifiersFields?.shift()]?.toString();
+            const id = Object.values(data.identifier)?.shift()?.toString();
             const collectionPath = this.buildCollectionPathForAdd(data);
             const collection = this.collection(collectionPath);
             if (isEmpty(id))
@@ -1427,9 +2059,12 @@ const withUpdateFirestore = (MixinBase) => {
             const model = new this.model();
             const keyField = model.identifiersFields.shift();
             const docRef = doc(this.collection(this.buildCollectionPathForUpdate(data)), getValueFromParams(data, keyField).toString());
-            await setDoc(docRef, this.paramsToPlain(data), { merge: true });
-            const docData = await getDoc(docRef);
-            return docData.data();
+            const plainFromData = this.model.toInstance(this.paramsToPlain(data));
+            const intercepted = await this.interceptors?.request?.({ instance: plainFromData });
+            const builded = intercepted?.instance || plainFromData;
+            await setDoc(docRef, builded.toPlain(), { merge: true });
+            const docData = await getDoc(docRef).then((doc) => doc.data());
+            return this.interceptors?.response?.(docData, intercepted) || docData;
         }
         buildCollectionPathForUpdate(identifiers) {
             return this.isSubCollection(this)
@@ -1451,7 +2086,11 @@ const withUpdateFirestore = (MixinBase) => {
 const withDeleteFirestore = (MixinBase) => {
     return class DeleteFirestore extends MixinBase {
         async delete(identifiers) {
-            await deleteDoc(doc(this.collection(this.buildCollectionPathForRemove(identifiers)), Object.values(identifiers).shift().toString()));
+            const instance = this.model.toInstance(this.model.identifiersFields.reduce((acc, field) => ({ ...acc, [field]: identifiers[field] }), {}));
+            const intercepted = await this.interceptors?.request?.({ instance });
+            const builded = intercepted?.instance || instance;
+            await deleteDoc(doc(this.collection(this.buildCollectionPathForRemove(identifiers)), Object.values(builded.identifier).shift().toString()));
+            await this.interceptors?.response?.(instance, intercepted);
         }
         buildCollectionPathForRemove(identifiers) {
             return this.isSubCollection(this)
@@ -1463,8 +2102,10 @@ const withDeleteFirestore = (MixinBase) => {
 
 const withSubCollection = (MixinBase, ParentModel) => {
     return class SubCollectionMix extends MixinBase {
-        constructor(...args) {
-            super(args);
+        constructor(...params) {
+            const options = params[0];
+            super(...params);
+            this.parentIdField = options.parentIdField;
         }
         collection(path) {
             return super.collection(path);
@@ -1478,73 +2119,87 @@ const withCrudFirestore = (MixinBase) => {
 };
 
 class LeadFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'leads';
-        this.model = Lead;
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'leads',
+            model: Lead,
+            interceptors,
+        });
     }
 }
 
 class SubscriptionEditionFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), Subscription) {
-    constructor(firestore, parentRepository) {
-        super();
-        this.firestore = firestore;
+    constructor({ firestore, interceptors }, parentRepository) {
+        super({
+            firestore,
+            collectionName: 'editions',
+            parentIdField: 'subscriptionId',
+            model: Edition,
+            interceptors,
+        });
         this.parentRepository = parentRepository;
-        this.collectionName = 'editions';
-        this.parentIdField = 'subscriptionId';
-        this.model = Edition;
     }
 }
 
 class SubscriptionFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'subscription';
-        this.model = Subscription;
+    constructor({ firestore, interceptors, }) {
+        super({
+            firestore,
+            collectionName: 'subscription',
+            model: Subscription,
+            interceptors,
+        });
     }
 }
 
 class SubscriptionPaymentFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), Subscription) {
-    constructor(firestore, parentRepository) {
-        super();
-        this.firestore = firestore;
+    constructor({ firestore, interceptors }, parentRepository) {
+        super({
+            firestore,
+            collectionName: 'payments',
+            parentIdField: 'subscriptionId',
+            model: SubscriptionPayment,
+            interceptors,
+        });
         this.parentRepository = parentRepository;
-        this.collectionName = 'payments';
-        this.parentIdField = 'subscriptionId';
-        this.model = SubscriptionPayment;
     }
 }
 
 class UserAddressFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), User) {
-    constructor(firestore, parentRepository) {
-        super();
-        this.firestore = firestore;
+    constructor({ firestore, interceptors }, parentRepository) {
+        super({
+            firestore,
+            collectionName: 'address',
+            parentIdField: 'userId',
+            model: UserAddress,
+            interceptors,
+        });
         this.parentRepository = parentRepository;
-        this.collectionName = 'address';
-        this.parentIdField = 'userId';
-        this.model = UserAddress;
     }
 }
 
 class UserBeautyProfileFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), User) {
-    constructor(firestore, parentRepository) {
-        super();
-        this.firestore = firestore;
+    constructor({ firestore, interceptors }, parentRepository) {
+        super({
+            firestore,
+            collectionName: 'CX',
+            parentIdField: 'userId',
+            model: BeautyProfile,
+            interceptors,
+        });
         this.parentRepository = parentRepository;
-        this.collectionName = 'CX';
-        this.parentIdField = 'userId';
-        this.model = BeautyProfile;
     }
 }
 
 class UserFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'users';
-        this.model = User;
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'users',
+            model: User,
+            interceptors,
+        });
     }
     async get(identifiers) {
         const user = await super.get({ id: identifiers.id });
@@ -1584,22 +2239,26 @@ class UserFirestoreRepository extends withCrudFirestore(withHelpers(withFirestor
 }
 
 class UserPaymentMethodFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), User) {
-    constructor(firestore, parentRepository) {
-        super();
-        this.firestore = firestore;
+    constructor({ firestore, interceptors }, parentRepository) {
+        super({
+            firestore,
+            collectionName: 'payment_method',
+            parentIdField: 'userId',
+            model: UserPaymentMethod,
+            interceptors,
+        });
         this.parentRepository = parentRepository;
-        this.collectionName = 'payment_method';
-        this.parentIdField = 'userId';
-        this.model = UserPaymentMethod;
     }
 }
 
 class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'categories';
-        this.model = Category;
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'categories',
+            model: Category,
+            interceptors,
+        });
     }
     async getCategoryBySlug(slug, shop) {
         const categoryDocs = await getDocs(query(this.collection(this.collectionName), where('slug', '==', slug), where('shop', '==', shop), where('published', '==', true)));
@@ -1609,14 +2268,14 @@ class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFire
             throw new NotFoundError(`Document with slug ${slug} not found`);
         return categoryDocs.docs[0].data();
     }
-    async getCategoriesForHome(categoryIds, limit = 4) {
+    async getCategoriesForHome(categoryIds, limit = 4, gender) {
         const categorySnap = await getDocs(query(this.collection(this.collectionName), where('id', 'in', categoryIds.filter(Boolean)), where('published', '==', true)));
         if (categorySnap.empty)
             throw new NotFoundError('Categories not found');
         const categories = categorySnap.docs.map((doc) => doc.data());
         const homeSections = await Promise.all(categories.map(async (category) => ({
             category,
-            products: await this.mountCategory(category, { limit, hasStock: true }),
+            products: await this.mountCategory(category, { limit, hasStock: true, gender }),
         })));
         return homeSections;
     }
@@ -1632,6 +2291,8 @@ class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFire
             wheres.push(where('published', '==', true), where('id', 'in', productIds));
             if (options?.hasStock)
                 wheres.push(where('stock.quantity', '>', 0));
+            if (options?.gender)
+                wheres.push(where('tags', 'array-contains', options?.gender));
             if (options?.limit)
                 wheres.push(limit(options?.limit));
             const productSnap = await getDocs(query(this.collection('productsErpVitrine'), ...wheres));
@@ -1641,15 +2302,26 @@ class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFire
         }
         return is(products);
     }
+    getCategoryByShop(shop) {
+        return;
+    }
+    getChildren(parentId) {
+        return;
+    }
+    isChild(id, parentId) {
+        return;
+    }
 }
 
 class ProductFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'productsErpVitrine',
+            model: Product,
+            interceptors,
+        });
         this.reviews = {};
-        this.collectionName = 'productsErpVitrine';
-        this.model = Product;
     }
     async getBySlug(slug) {
         const result = await this.find({
@@ -1684,43 +2356,101 @@ class ProductFirestoreRepository extends withCrudFirestore(withHelpers(withFires
         });
         return this.reviews[status];
     }
+    cleanShoppingCountFromIds() {
+        return;
+    }
+    findCatalog(params) {
+        return this.find(params);
+    }
 }
 
 class ProductVariantFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), Product) {
-    constructor(firestore, parentRepository) {
-        super();
-        this.firestore = firestore;
+    constructor({ firestore, interceptors }, parentRepository) {
+        super({
+            firestore,
+            collectionName: 'variants',
+            parentIdField: 'productId',
+            model: Variant,
+            interceptors,
+        });
         this.parentRepository = parentRepository;
-        this.collectionName = 'variants';
-        this.parentIdField = 'productId';
-        this.model = Variant;
     }
 }
 
 class SubscriptionProductFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'subscriptionProducts';
-        this.model = Product;
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'subscriptionProducts',
+            model: Product,
+            interceptors,
+        });
+    }
+}
+
+class Buy2WinFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'buy2win',
+            model: Buy2Win,
+            interceptors,
+        });
+    }
+}
+
+class CampaignDashboardFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, }) {
+        super({
+            firestore,
+            collectionName: 'dashboardCampaignsAuto',
+            model: CampaignDashboard,
+            interceptors,
+        });
+    }
+}
+
+class CampaignHashtagFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, }) {
+        super({
+            firestore,
+            collectionName: 'hashtagCampaignsAuto',
+            model: CampaignHashtag,
+            interceptors,
+        });
     }
 }
 
 class CheckoutFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'checkouts';
-        this.model = Checkout;
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'checkouts',
+            model: Checkout,
+            interceptors,
+        });
+    }
+}
+
+class CheckoutSubscriptionFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, }) {
+        super({
+            firestore,
+            collectionName: 'checkoutsSubscription',
+            model: CheckoutSubscription,
+            interceptors,
+        });
     }
 }
 
 class CouponFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'coupons';
-        this.model = Coupon;
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'coupons',
+            model: Coupon,
+            interceptors,
+        });
     }
     buildModelInstance() {
         const { fromFirestore, toFirestore } = super.buildModelInstance();
@@ -1742,9 +2472,16 @@ class CouponFirestoreRepository extends withCrudFirestore(withHelpers(withFirest
 }
 
 class OrderFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'orders',
+            model: Order,
+            interceptors,
+            fields: {
+                status: FirestoreFieldType.String,
+            },
+        });
         this.orderFromFirestore = (order) => {
             if (!!order?.lineItems?.length) {
                 order.lineItems = order.lineItems.map((lineItem) => {
@@ -1757,11 +2494,6 @@ class OrderFirestoreRepository extends withCrudFirestore(withHelpers(withFiresto
             }
             return order;
         };
-        this.collectionName = 'orders';
-        this.model = Order;
-        this.fields = {
-            status: FirestoreFieldType.String,
-        };
     }
     buildModelInstance() {
         const { fromFirestore, toFirestore } = super.buildModelInstance();
@@ -1775,84 +2507,58 @@ class OrderFirestoreRepository extends withCrudFirestore(withHelpers(withFiresto
     }
 }
 
-class PaymentFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'payments';
-        this.model = Payment;
+class LegacyOrderFirestoreRepository extends OrderFirestoreRepository {
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            interceptors,
+        });
+        this.collectionName = 'legacyOrders';
     }
 }
 
-class CheckoutSubscriptionFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'checkoutsSubscription';
-        this.model = CheckoutSubscription;
+class PaymentFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'payments',
+            model: Payment,
+            interceptors,
+        });
     }
 }
 
 class SubscriptionPlanFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'subscriptionPlans';
-        this.model = SubscriptionPlan;
-    }
-}
-
-class Buy2WinFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'buy2win';
-        this.model = Buy2Win;
-    }
-}
-
-class LegacyOrderFirestoreRepository extends OrderFirestoreRepository {
-    constructor(firestore) {
-        super(firestore);
-        this.firestore = firestore;
-        this.collectionName = 'legacyOrders';
+    constructor({ firestore, interceptors, }) {
+        super({
+            firestore,
+            collectionName: 'subscriptionPlans',
+            model: SubscriptionPlan,
+            interceptors,
+        });
     }
 }
 
 class HomeFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.homeToFirestore = (home) => {
-            if (home.data?.data) {
-                home.data.data.discoverProducts = home.data.data.discoverProducts.map(this.homeCategoryGroupToPlain);
-                home.data.data.featuredProducts = home.data.data.featuredProducts.map(this.homeCategoryGroupToPlain);
-                home.data.data.verticalProducts = home.data.data.verticalProducts.map(this.homeCategoryGroupToPlain);
-            }
-            return home;
-        };
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'dms',
+            model: Home,
+            interceptors,
+        });
         this.homeCategoryGroupToPlain = (homeCategoryGroup) => ({
-            category: homeCategoryGroup.category.toPlain(),
-            products: homeCategoryGroup.products.map((product) => product.toPlain()),
-        });
-        this.homeFromFirestore = (home) => {
-            if (home.data?.data) {
-                home.data.data.discoverProducts = home.data.data.discoverProducts.map(this.plainToHomeCategoryGroup);
-                home.data.data.featuredProducts = home.data.data.featuredProducts.map(this.plainToHomeCategoryGroup);
-                home.data.data.verticalProducts = home.data.data.verticalProducts.map(this.plainToHomeCategoryGroup);
-                home.data.createdAt =
-                    home.data.createdAt instanceof Timestamp ? home.data.createdAt.toDate() : home.data.createdAt;
-                home.data.expiresAt =
-                    home.data.expiresAt instanceof Timestamp ? home.data.expiresAt.toDate() : home.data.expiresAt;
-            }
-            return home;
-        };
+            category: homeCategoryGroup?.category?.toPlain
+                ? homeCategoryGroup?.category?.toPlain()
+                : homeCategoryGroup?.category,
+            products: homeCategoryGroup?.products
+                ?.map((product) => (product?.toPlain ? product?.toPlain() : product))
+                .filter(Boolean) || [],
+        });
         this.plainToHomeCategoryGroup = (homeCategoryGroup) => ({
-            category: Category.toInstance(homeCategoryGroup.category),
-            products: homeCategoryGroup.products.map((product) => Product.toInstance(product)),
+            category: Category.toInstance(homeCategoryGroup?.category),
+            products: homeCategoryGroup.products?.map((product) => Product.toInstance(product)),
         });
-        this.collectionName = 'dms';
-        this.model = Home;
     }
     buildModelInstance() {
         const { fromFirestore, toFirestore } = super.buildModelInstance();
@@ -1867,14 +2573,47 @@ class HomeFirestoreRepository extends withCrudFirestore(withHelpers(withFirestor
             },
         };
     }
+    homeToFirestore(home) {
+        if (home.data?.data) {
+            home.data.data.discoverProducts = home.data.data.discoverProducts?.map(this.homeCategoryGroupToPlain) || [];
+            home.data.data.featuredProducts = home.data.data.featuredProducts?.map(this.homeCategoryGroupToPlain) || [];
+            home.data.data.verticalProducts = home.data.data.verticalProducts?.map(this.homeCategoryGroupToPlain) || [];
+        }
+        return home;
+    }
+    homeFromFirestore(home) {
+        if (home.data?.data) {
+            home.data.data.discoverProducts = home.data.data.discoverProducts.map(this.plainToHomeCategoryGroup);
+            home.data.data.featuredProducts = home.data.data.featuredProducts.map(this.plainToHomeCategoryGroup);
+            home.data.data.verticalProducts = home.data.data.verticalProducts.map(this.plainToHomeCategoryGroup);
+            home.data.createdAt =
+                home.data.createdAt instanceof Timestamp ? home.data.createdAt.toDate() : home.data.createdAt;
+            home.data.expiresAt =
+                home.data.expiresAt instanceof Timestamp ? home.data.expiresAt.toDate() : home.data.expiresAt;
+        }
+        return home;
+    }
 }
 
 class ShopMenuFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor(firestore) {
-        super();
-        this.firestore = firestore;
-        this.collectionName = 'shopMenus';
-        this.model = ShopMenu;
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'shopMenus',
+            model: ShopMenu,
+            interceptors,
+        });
+    }
+}
+
+class ShopSettingsFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, }) {
+        super({
+            firestore,
+            collectionName: 'shopSettings',
+            model: ShopSettings,
+            interceptors,
+        });
     }
 }
 
@@ -1951,7 +2690,7 @@ class AttributeOptionHelper {
 }
 AttributeOptionHelper.FindByAttribute = (attributeName, fields) => {
     if (fields.includes(attributeName))
-        return { columnName: attributeName.toString(), attributeName };
+        return { columnName: attributeName.toString(), attributeName, to: (value) => value, from: (value) => value };
     const field = fields.find((columnOption) => isObject(columnOption) && Object.keys(columnOption).includes(attributeName.toString()));
     const fieldOption = is(field)?.[attributeName];
     if (isNil(fieldOption))
@@ -1960,7 +2699,7 @@ AttributeOptionHelper.FindByAttribute = (attributeName, fields) => {
         return { columnName: attributeName.toString(), attributeName, fields: fieldOption };
     return { attributeName, columnName: attributeName.toString(), ...fieldOption };
 };
-AttributeOptionHelper.CheckIsColumnOption = (fieldValue) => !!fieldValue.columnName;
+AttributeOptionHelper.CheckIsColumnOption = (fieldValue) => !!fieldValue?.columnName;
 AttributeOptionHelper.FindColumnOptionFromList = (columnName, fields) => {
     if (fields.includes(columnName))
         return { columnName, attributeName: columnName };
@@ -2053,25 +2792,26 @@ BindFilterQueryHelper.MakeGraphQLWhere = (filter, fields) => Object.keys(filter)
 }, {});
 BindFilterQueryHelper.BuildWhereSentence = (field, options, fields) => {
     const fieldSentenceOptions = AttributeOptionHelper.FindByAttribute(field, fields);
-    if (!Array.isArray(options) &&
+    const isNestedField = !Array.isArray(options) &&
         isObject(options) &&
         isNil(options?.operator) &&
         isNil(options?.value) &&
-        isNil(fieldSentenceOptions?.to))
+        isNil(fieldSentenceOptions?.to);
+    if (isNestedField)
         return Object.keys(options).reduce((variables, key) => {
             const fieldOptions = AttributeOptionHelper.FindByAttribute(key, fieldSentenceOptions?.fields || fields);
             const columnName = fieldOptions.columnName;
             const columnFields = fieldOptions.fields;
             return {
                 ...variables,
-                [columnName]: BindFilterQueryHelper.BuildWhereSentence(key, is(is(options)[key]), columnFields || []),
+                [columnName]: BindFilterQueryHelper.BuildWhereSentence(key, is(is(options)[key]), fieldSentenceOptions?.fields || columnFields || fields),
             };
         }, {});
     if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))
         return {
             [fieldSentenceOptions.fields[0]]: BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions),
         };
-    if (isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
+    if (!Array.isArray(options) && isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
         options = Object.values(options)[0];
     return Array.isArray(options)
         ? options.reduce((whereSentence, option) => ({
@@ -2107,28 +2847,14 @@ GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields = (fields) => {
         if (field === 'affected_rows')
             return field;
         const fieldName = Object.keys(field).shift();
-        const fieldValue = field[fieldName];
+        const fieldValue = is(field[fieldName]);
         if (Array.isArray(fieldValue))
             return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) };
         if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue))
-            return null;
-        if (fieldValue.fields)
-            return !fieldValue.filters
-                ? {
-                    [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
-                }
-                : {
-                    operation: fieldValue.columnName || fieldName,
-                    fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
-                    variables: {
-                        [`${fieldValue.columnName}_where`]: {
-                            name: 'where',
-                            type: fieldValue.filters.filterType,
-                            value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),
-                            required: true,
-                        },
-                    },
-                };
+            return;
+        const isNestedField = !!fieldValue.fields;
+        if (isNestedField)
+            return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue);
         return fieldValue.columnName;
     })
         .filter((field) => !!field);
@@ -2153,7 +2879,10 @@ GraphQLFieldHelper.ConvertFieldValueFrom = (data, fields) => Object.keys(data).r
     }
     if (!!from)
         return { ...result, [attributeName]: from(data[columnName], data) };
-    return { ...result, [attributeName]: parseDateTime(data[columnName].toString()) };
+    return {
+        ...result,
+        [attributeName]: isString(data[columnName]) ? parseDateTime(data[columnName].toString()) : data[columnName],
+    };
 }, {});
 GraphQLFieldHelper.ConvertFieldValueTo = (instance, fields, update = false) => {
     const data = instance.toPlain?.() || instance;
@@ -2169,10 +2898,13 @@ GraphQLFieldHelper.ConvertFieldValueTo = (instance, fields, update = false) => {
         if (!!foreignKeyColumn &&
             !isEmpty(foreignKeyColumn) &&
             !Object.keys(foreignKeyColumn).filter((key) => !is(data[attributeName])?.[key]).length)
-            return Object.keys(foreignKeyColumn).reduce((object, current) => ({
-                ...object,
-                [foreignKeyColumn[current]]: data[attributeName]?.[current],
-            }), { ...result });
+            return Object.keys(foreignKeyColumn).reduce((object, current) => {
+                const { columnName: foreignColumnName } = AttributeOptionHelper.FindByAttribute(foreignKeyColumn[current], fields);
+                return {
+                    ...object,
+                    [foreignColumnName]: data[attributeName]?.[current],
+                };
+            }, { ...result });
         if (update &&
             isObject(data[attributeName]) &&
             !isNil(attributeFields) &&
@@ -2205,6 +2937,25 @@ GraphQLFieldHelper.ConvertFieldValueTo = (instance, fields, update = false) => {
         return { ...result, [columnName]: data[attributeName] };
     }, {});
 };
+GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields = (fieldName, fieldValue) => {
+    const hasCustomFilters = !!fieldValue.filters;
+    if (hasCustomFilters)
+        return {
+            operation: fieldValue.columnName || fieldName,
+            fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+            variables: {
+                [`${fieldValue.columnName}_where`]: {
+                    name: 'where',
+                    type: fieldValue.filters.filterType,
+                    value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),
+                    required: true,
+                },
+            },
+        };
+    return {
+        [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+    };
+};
 
 const withCreateHasuraGraphQL = (MixinBase) => {
     return class CreateHasuraGraphQLMixin extends MixinBase {
@@ -2215,6 +2966,7 @@ const withCreateHasuraGraphQL = (MixinBase) => {
             this.insertGraphQLObjectType = options?.insertGraphQLObjectType || `${this.tableName}_insert_input`;
         }
         async create(data) {
+            this.logger = DebugHelper.from(this, 'create');
             const newData = await this.save(this.model.toInstance(data));
             return this.model.toInstance(newData);
         }
@@ -2225,10 +2977,10 @@ const withCreateHasuraGraphQL = (MixinBase) => {
                 const columnOptions = Object.values(field).shift();
                 return (AttributeOptionHelper.CheckIsColumnOption(columnOptions) &&
                     columnOptions.foreignKeyColumn && [
-                    ...Object.values(columnOptions.foreignKeyColumn),
+                    ...Object.values(columnOptions.foreignKeyColumn).map((foreignKeyName) => AttributeOptionHelper.FindByAttribute(foreignKeyName, this.fields)?.columnName),
                     {
-                        [columnOptions.columnName]: Object.keys(columnOptions.foreignKeyColumn).map((foreignKeyField) => AttributeOptionHelper.FindByAttribute(foreignKeyField, columnOptions?.fields)?.columnName ||
-                            foreignKeyField),
+                        [columnOptions.columnName]: Object.keys(columnOptions.foreignKeyColumn).map((foreignKeyField) => AttributeOptionHelper.FindByAttribute(foreignKeyField, columnOptions?.fields)
+                            ?.columnName || foreignKeyField),
                     },
                 ]);
             })
@@ -2250,9 +3002,11 @@ const withDeleteHasuraGraphQL = (MixinBase) => {
             this.deleteGraphQLOperation = options?.deleteGraphQLOperation || `delete_${this.tableName}_by_pk`;
         }
         async delete(identifiers) {
+            this.logger = DebugHelper.from(this, 'delete');
             const instance = this.model.toInstance(identifiers);
             await this.mutation(this.deleteGraphQLOperation, this.model.identifiersFields.map((field) => AttributeOptionHelper.FindByAttribute(field, this.fields).columnName), this.model.identifiersFields.reduce((ids, identifier) => {
-                if (isNil(instance[identifier]))
+                const identifierBinded = identifier;
+                if (isNil(instance.identifier[identifierBinded]))
                     return ids;
                 const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields);
                 const value = columnOption.to(identifiers[identifier], instance);
@@ -2279,15 +3033,19 @@ const withHasuraGraphQL = (MixinBase) => {
             this.authOptions = options.authOptions;
             this.model = options.model;
             this.fields = options.fields || this.model.identifiersFields;
+            this.logger = DebugHelper.from(this);
         }
         get headers() {
             return {
                 'Content-Type': 'application/json',
-                ...(isNil(this.authOptions.authToken) ? {} : { Authorization: this.authOptions.authToken }),
-                ...(isNil(this.authOptions.adminSecret) ? {} : { 'X-Hasura-Admin-Secret': this.authOptions.adminSecret }),
-                ...(isNil(this.authOptions.authRole)
+                ...(isNil(this.authOptions?.authToken) ? {} : { Authorization: this.authOptions?.authToken }),
+                ...(isNil(this.authOptions?.adminSecret) ? {} : { 'X-Hasura-Admin-Secret': this.authOptions?.adminSecret }),
+                ...(isNil(this.authOptions?.authRole)
                     ? {}
-                    : { 'X-Hasura-Role': this.authOptions.authRole.role, 'X-Hasura-User-Id': this.authOptions.authRole.userId }),
+                    : {
+                        'X-Hasura-Role': this.authOptions.authRole.role,
+                        'X-Hasura-User-Id': this.authOptions?.authRole?.userId,
+                    }),
             };
         }
         async mutation(operation, fields, variables) {
@@ -2299,29 +3057,28 @@ const withHasuraGraphQL = (MixinBase) => {
             return this.fetch(resultQuery);
         }
         async query(operation, fields, variables) {
-            const resultQuery = GraphQLFieldHelper.CheckIsGraphQLParams(operation)
-                ? query$1(operation.map((option) => ({
-                    operation: option.operation,
-                    variables: option.variables,
-                    fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(option.fields),
-                })))
-                : query$1({
-                    operation,
-                    variables,
-                    fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fields),
-                });
-            return this.fetch(resultQuery);
+            const builded = this.buildHasuraQueryFields({
+                operation,
+                fields: fields,
+                variables,
+            });
+            const interpected = (await this.interceptors?.request?.(builded)) || builded;
+            const resultQuery = query$1(interpected);
+            const result = await this.fetch(resultQuery);
+            return (await this.interceptors?.response?.(result, interpected)) || result;
         }
         async fetch(params) {
+            this.logger.with('params').log(params);
             const headers = this.headers;
-            const response = await fetch(`${this.endpoint}`, {
+            const { data: result } = await axios({
+                url: `${this.endpoint}`,
                 method: 'POST',
-                body: JSON.stringify(params),
+                data: params,
                 headers,
             });
-            const result = await response.json();
             if (!isNil(result.errors))
                 throw new Error(JSON.stringify(result.errors));
+            this.logger.with('returns').log(result);
             return result.data;
         }
         getAttributeGraphQLTypeOf(value) {
@@ -2347,13 +3104,26 @@ const withHasuraGraphQL = (MixinBase) => {
                 return value;
             return date;
         }
-        convertDataFromHasura(data) {
-            const plain = GraphQLFieldHelper.ConvertFieldValueFrom(data, this.fields);
+        convertDataFromHasura(data, fields) {
+            const plain = GraphQLFieldHelper.ConvertFieldValueFrom(data, fields || this.fields);
             return this.model.toInstance(plain);
         }
         convertDataToHasura(instance, update = false) {
             return GraphQLFieldHelper.ConvertFieldValueTo(instance, this.fields, update);
         }
+        buildHasuraQueryFields({ operation, fields, variables, }) {
+            return GraphQLFieldHelper.CheckIsGraphQLParams(operation)
+                ? operation.map((option) => ({
+                    operation: option.operation,
+                    variables: option.variables,
+                    fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(option.fields),
+                }))
+                : {
+                    operation,
+                    variables,
+                    fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fields),
+                };
+        }
     };
 };
 
@@ -2376,6 +3146,7 @@ const withUpdateHasuraGraphQL = (MixinBase) => {
             this.updateGraphQLPKType = options?.updateGraphQLPKType || `${this.tableName}_pk_columns_input`;
         }
         async update(data) {
+            this.logger = DebugHelper.from(this, 'update');
             const plainData = this.paramsToPlain(data);
             await this.mutation(this.updateGraphQLOperation, this.model.identifiersFields.map((field) => AttributeOptionHelper.FindByAttribute(field, this.fields).columnName), {
                 _set: {
@@ -2401,10 +3172,11 @@ const withUpdateHasuraGraphQL = (MixinBase) => {
         getUpdateModelKeys(data) {
             const instance = this.model.toInstance(data);
             return this.model.identifiersFields.reduce((ids, identifier) => {
-                if (isNil(instance[identifier]))
+                const identifierBinded = identifier;
+                if (isNil(instance.identifier[identifierBinded]))
                     return ids;
-                const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields);
-                const value = columnOption?.to?.(data[identifier], instance) || data[columnOption.attributeName];
+                const columnOption = AttributeOptionHelper.FindByAttribute(identifierBinded, this.fields);
+                const value = columnOption?.to?.(data[identifierBinded], instance) || data[columnOption.attributeName];
                 return {
                     ...ids,
                     [columnOption.columnName]: value,
@@ -2422,9 +3194,11 @@ const withGetHasuraGraphQL = (MixinBase) => {
             this.getGraphQLOperation = options?.getGraphQLOperation || `${this.tableName}_by_pk`;
         }
         async get(identifiers) {
+            this.logger = DebugHelper.from(this, 'get');
             const instance = this.model.toInstance(identifiers);
             const result = await this.query(this.getGraphQLOperation, this.fields, this.model.identifiersFields.reduce((ids, identifier) => {
-                if (isNil(instance[identifier]))
+                const identifierBinded = identifier;
+                if (isNil(instance[identifierBinded]))
                     return ids;
                 const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields);
                 const value = columnOption?.to?.(identifiers[identifier], instance) ||
@@ -2448,44 +3222,150 @@ const withGetHasuraGraphQL = (MixinBase) => {
 
 const withFindHasuraGraphQL = (MixinBase) => {
     return class FindHasuraGraphQLMixin extends MixinBase {
-        async find(options) {
-            const { filters, limits, orderBy } = options || {};
+        constructor() {
+            super(...arguments);
+            this.bindOrderByAttributes = (orderBy, fields) => Object.keys(orderBy).reduce((acc, current) => [
+                ...acc,
+                {
+                    [AttributeOptionHelper.FindByAttribute(current, fields)
+                        .columnName]: orderBy[current] === 'asc'
+                        ? 'asc_nulls_last'
+                        : 'desc_nulls_last',
+                },
+            ], []);
+            this.bindAggretageAttributes = (aggregates, fields) => [
+                ...(aggregates?.minimal?.length
+                    ? [
+                        {
+                            min: this.bindAttributesToColumns(aggregates?.minimal, fields),
+                        },
+                    ]
+                    : []),
+                ...(aggregates?.maximum?.length
+                    ? [
+                        {
+                            max: this.bindAttributesToColumns(aggregates?.maximum, fields),
+                        },
+                    ]
+                    : []),
+            ];
+            this.bindDistinctAttributes = (distinct, fields) => this.bindAttributesToColumns(distinct, fields);
+            this.bindAttributesToColumns = (attributes, fields) => attributes.map((attr) => AttributeOptionHelper.FindByAttribute(attr.toString().split('.').pop(), fields)?.columnName || attr);
+        }
+        async find(params) {
+            this.logger = DebugHelper.from(this, 'find');
+            const { filters, limits, orderBy, options } = params || {};
+            const enableCount = options?.enableCount ?? true;
+            const variablesFilters = isNil(filters)
+                ? {}
+                : {
+                    where: {
+                        value: BindFilterQueryHelper.MakeGraphQLWhere(filters, this.fields),
+                        type: `${this.tableName}_bool_exp`,
+                        required: true,
+                    },
+                };
             const variablesCount = {
-                ...(isNil(orderBy) ? {} : { order_by: { type: `${this.tableName}_order_by!`, list: true, value: orderBy } }),
-                ...(isNil(filters)
+                ...(isNil(orderBy)
                     ? {}
                     : {
-                        where: {
-                            value: BindFilterQueryHelper.MakeGraphQLWhere(filters, this.fields),
-                            type: `${this.tableName}_bool_exp`,
-                            required: true,
+                        order_by: {
+                            type: `${this.tableName}_order_by!`,
+                            list: true,
+                            value: this.bindOrderByAttributes(orderBy, this.fields),
                         },
                     }),
+                ...variablesFilters,
             };
             const variables = {
                 ...(isNil(limits) ? {} : limits),
                 ...variablesCount,
             };
+            const aggregateFields = [
+                ...(enableCount ? ['count'] : []),
+                ...this.bindAggretageAttributes(params.options, this.fields),
+            ];
             const result = await this.query([
                 {
                     operation: this.tableName,
-                    fields: options.fields
-                        ? options.fields
+                    fields: params.fields
+                        ? params.fields
                             .map((fieldName) => this.fields.find((fieldOption) => fieldOption === fieldName) ??
                             this.fields.find((fieldOption) => Object.keys(fieldOption).shift() === fieldName))
                             .filter(Boolean)
                         : this.fields,
                     variables,
                 },
-                {
-                    operation: `${this.tableName}_aggregate`,
-                    fields: [{ aggregate: ['count'] }],
-                    variables: variablesCount,
-                },
+                ...(aggregateFields.length > 0
+                    ? [
+                        {
+                            operation: `${this.tableName}_aggregate`,
+                            fields: [
+                                {
+                                    aggregate: aggregateFields,
+                                },
+                            ],
+                            variables: variablesCount,
+                        },
+                    ]
+                    : []),
+                ...((!params.limits?.offset &&
+                    params.options?.distinct?.map((distinct) => {
+                        const distinctOption = this.fields.find((fieldOption) => fieldOption === distinct) ??
+                            this.fields.find((fieldOption) => Object.keys(fieldOption).shift() === distinct);
+                        const fieldName = Object.values(distinctOption).shift()?.columnName || distinct;
+                        return {
+                            operation: {
+                                name: `${this.tableName}`,
+                                alias: `${this.tableName}_${distinct.toString()}_distinct`,
+                            },
+                            fields: [distinctOption],
+                            variables: {
+                                ...variablesFilters,
+                                [`${this.tableName}_${fieldName}_distinct`]: {
+                                    type: `${this.tableName}_select_column!`,
+                                    list: true,
+                                    value: fieldName,
+                                    name: 'distinct_on',
+                                },
+                            },
+                        };
+                    })) ||
+                    []),
             ]);
             const data = result[this.tableName].map((row) => this.convertDataFromHasura(row));
-            const count = result[`${this.tableName}_aggregate`].aggregate.count;
-            return { count, data };
+            return {
+                data,
+                count: enableCount ? result[`${this.tableName}_aggregate`].aggregate.count : Infinity,
+                ...(options?.minimal?.length
+                    ? {
+                        minimal: options.minimal.reduce((minimals, current) => ({
+                            ...minimals,
+                            ...set(minimals, current, result[`${this.tableName}_aggregate`].aggregate.min[AttributeOptionHelper.FindByAttribute(current.toString().split('.').pop(), this.fields)?.columnName || current]),
+                        }), {}),
+                    }
+                    : {}),
+                ...(options?.maximum?.length
+                    ? {
+                        maximum: options.maximum.reduce((maximums, current) => ({
+                            ...maximums,
+                            ...set(maximums, current, result[`${this.tableName}_aggregate`].aggregate.max[AttributeOptionHelper.FindByAttribute(current.toString().split('.').pop(), this.fields)?.columnName || current]),
+                        }), {}),
+                    }
+                    : {}),
+                ...(!params.limits?.offset &&
+                    options?.distinct?.length && {
+                    distinct: options?.distinct.reduce((distinct, current) => {
+                        const distinctOption = this.fields.find((fieldOption) => fieldOption === current) ??
+                            this.fields.find((fieldOption) => Object.keys(fieldOption).shift() === current);
+                        const fieldName = Object.values(distinctOption).shift()?.columnName || current;
+                        return {
+                            ...distinct,
+                            [current.toString()]: result[`${this.tableName}_${current.toString()}_distinct`].map((obj) => obj[fieldName]),
+                        };
+                    }, {}),
+                }),
+            };
         }
     };
 };
@@ -2524,13 +3404,154 @@ class VariantHasuraGraphQL extends Variant {
     }
 }
 
+class CategoryCollectionChildrenHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, }) {
+        super({
+            tableName: 'category_collection_children',
+            model: CategoryCollectionChildren,
+            endpoint,
+            authOptions,
+            interceptors,
+            fields: [
+                { collectionId: { columnName: 'collection_id' } },
+                { categoryId: { columnName: 'category_id' } },
+                'name',
+                'slug',
+                'reference',
+                { parentCollectionId: { columnName: 'parent_collection_id' } },
+                { parentCategoryId: { columnName: 'parent_category_id' } },
+                {
+                    parent: {
+                        columnName: 'parent',
+                        foreignKeyColumn: { collectionId: 'parentCollectionId', categoryId: 'parentCategoryId' },
+                        fields: [
+                            { collectionId: { columnName: 'collection_id' } },
+                            { categoryId: { columnName: 'category_id' } },
+                            'name',
+                            'slug',
+                            'reference',
+                            { parentCollectionId: { columnName: 'parent_collection_id' } },
+                            { parentCategoryId: { columnName: 'parent_category_id' } },
+                        ],
+                    },
+                },
+            ],
+        });
+    }
+}
+
+class CategoryFilterHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, }) {
+        super({
+            tableName: 'category_filter',
+            model: CategoryFilter,
+            endpoint,
+            authOptions,
+            interceptors,
+            fields: [
+                'id',
+                { filterId: { columnName: 'filter_id' } },
+                { categoryId: { columnName: 'category_id' } },
+                {
+                    filter: {
+                        columnName: 'filter',
+                        foreignKeyColumn: { id: 'filterId' },
+                        fields: [
+                            'id',
+                            'description',
+                            'slug',
+                            'enabled',
+                            { createdAt: { columnName: 'created_at' } },
+                            { updatedAt: { columnName: 'updated_at' } },
+                            {
+                                options: {
+                                    columnName: 'options',
+                                    foreignKeyColumn: { filterId: 'id' },
+                                    fields: [
+                                        'id',
+                                        { filterId: { columnName: 'filter_id' } },
+                                        'description',
+                                        { createdAt: { columnName: 'created_at' } },
+                                        { updatedAt: { columnName: 'updated_at' } },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                },
+                {
+                    category: {
+                        columnName: 'category',
+                        foreignKeyColumn: { id: 'categoryId' },
+                        fields: [
+                            'id',
+                            'description',
+                            {
+                                products: {
+                                    columnName: 'products',
+                                    fields: ['product_id'],
+                                    from: (value) => value.map((product) => product.product_id.toString()),
+                                    to: (productIds) => productIds.map((productId) => ({
+                                        product_id: +productId,
+                                    })),
+                                },
+                            },
+                            {
+                                childrenProducts: {
+                                    columnName: 'children_products',
+                                    foreignKeyColumn: { category_id: 'id' },
+                                    fields: [
+                                        'id',
+                                        'name',
+                                        'slug',
+                                        {
+                                            categories: {
+                                                columnName: 'categories',
+                                                fields: ['category_id'],
+                                                bindPersistData: (value) => ({
+                                                    categories: { data: value.map((category) => ({ category_id: +category })) },
+                                                }),
+                                                to: (categories) => categories.map((categoryId) => +categoryId),
+                                                from: (categories) => categories?.map((category) => category?.category_id?.toString()) || [],
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                },
+            ],
+        });
+    }
+    deleteByCategory(categoryId) {
+        return this.mutation('delete_category_filter', ['affected_rows'], {
+            where: {
+                type: 'category_filter_bool_exp',
+                required: true,
+                value: { category_id: { _eq: categoryId } },
+            },
+        });
+    }
+    deleteByCategoryAndFilter(categoryId, filterId) {
+        return this.mutation('delete_category_filter', ['affected_rows'], {
+            where: {
+                type: 'category_filter_bool_exp',
+                required: true,
+                value: { category_id: { _eq: categoryId }, filter_id: { _eq: filterId } },
+            },
+        });
+    }
+}
+
 class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
-    constructor(endpoint, authOptions, productRepository) {
+    constructor({ endpoint, authOptions, interceptors, }, productRepository, categoryFilterRepository) {
         super({
             tableName: 'category',
             model: Category,
             endpoint,
             authOptions,
+            interceptors,
             fields: [
                 { id: { columnName: 'id', to: (value) => +value, from: (value) => value.toString() } },
                 { firestoreId: { columnName: 'firestore_id' } },
@@ -2539,6 +3560,7 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
                 'image',
                 'published',
                 'shop',
+                { shops: { columnName: 'shops', type: HasuraGraphQLColumnType.Jsonb } },
                 'slug',
                 { brandCategory: { columnName: 'brand_category' } },
                 { brandCategoryBanner: { columnName: 'brand_banner' } },
@@ -2567,7 +3589,17 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
                         },
                     },
                 },
-                'filters',
+                {
+                    filters: {
+                        columnName: 'filters',
+                        foreignKeyColumn: { filter_id: 'id' },
+                        fields: [{ filter: ['id', 'description', 'slug', 'enabled'] }],
+                        bindPersistData: (value) => ({
+                            filters: { data: value.map((filter) => ({ filter_id: filter.id })) },
+                        }),
+                        from: (filters) => filters?.map((filter) => filter?.filter) || [],
+                    },
+                },
                 { createdAt: { columnName: 'created_at' } },
                 { updatedAt: { columnName: 'updated_at' } },
                 {
@@ -2589,39 +3621,77 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
                         }),
                     },
                 },
+                { isCollection: { columnName: 'is_collection' } },
+                { isWishlist: { columnName: 'is_wishlist' } },
+                'reference',
+                { parentId: { columnName: 'parent_id' } },
+                {
+                    parent: {
+                        columnName: 'parent',
+                        foreignKeyColumn: { id: 'parentId' },
+                        fields: ['id', 'name', 'reference', 'slug'],
+                    },
+                },
             ],
         });
         this.productRepository = productRepository;
+        this.categoryFilterRepository = categoryFilterRepository;
     }
     async create(params) {
         const { metadata, ...data } = params;
-        return super.create({ ...data, metadata: metadata || { description: null, title: null } });
+        return super.create({ ...data, isWishlist: false, metadata: metadata || { description: null, title: null } });
     }
     async get(identifiers) {
         return Number.isNaN(+identifiers.id)
-            ? (await this.find({ filters: { firestoreId: identifiers.id } })).data?.[0]
+            ? (await this.find({ filters: { firestoreId: identifiers.id }, options: { enableCount: false } })).data?.[0]
             : super.get(identifiers);
     }
     async update(params) {
-        const { products, id: checkId, metadata, ...data } = params;
+        const { products, id: checkId, metadata, filters, ...data } = params;
         const plainData = this.paramsToPlain({ id: checkId });
         const id = await this.getId(plainData.id);
-        const category = await super.update({ id, ...data });
+        const category = await super.update({ id, ...data, isWishlist: false });
         category.products = products && (await this.updateProducts(+id, { products }));
         category.metadata = metadata && (await this.updateMetadata(+id, { metadata }));
+        category.filters = filters && (await this.updateFilters(+id, { filters }));
         return category;
     }
     async getCategoryBySlug(slug, shop) {
         if (!slug)
             return null;
-        const { data, count } = await this.find({ filters: { slug, shop, published: true } });
-        if (count > 1)
-            throw new DuplicatedResultsError('Query returned duplicated values');
-        if (!count)
+        const { data } = await this.find({
+            filters: {
+                slug,
+                shops: { operator: Where.IN, value: [shop] },
+                published: { operator: Where.EQUALS, value: true },
+                isWishlist: { operator: Where.EQUALS, value: false },
+            },
+            options: {
+                enableCount: false,
+            },
+        });
+        if (!data.length)
             throw new NotFoundError(`Category with slug ${slug} not found`);
+        if (data.length > 1)
+            throw new DuplicatedResultsError('Query returned duplicated values');
         return data.shift();
     }
-    async getCategoriesForHome(categoryIds, limit = 4) {
+    async getCategoryByShop(shop) {
+        if (!shop)
+            return;
+        const { data } = await this.find({
+            filters: {
+                shops: { operator: Where.IN, value: [shop] },
+                published: { operator: Where.EQUALS, value: true },
+                isWishlist: { operator: Where.EQUALS, value: false },
+            },
+            options: {
+                enableCount: false,
+            },
+        });
+        return data;
+    }
+    async getCategoriesForHome(categoryIds, limit = 4, gender) {
         if (!categoryIds?.length)
             return [];
         const categoriesFirestore = categoryIds.filter((categoryId) => Number.isNaN(+categoryId));
@@ -2639,7 +3709,7 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
             return [];
         const homeSections = await Promise.all(categories.map(async (category) => ({
             category,
-            products: await this.mountCategory(category, { limit, hasStock: true }),
+            products: await this.mountCategory(category, { limit, hasStock: true, gender }),
         })));
         return homeSections;
     }
@@ -2652,6 +3722,7 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
                 id: { operator: Where.IN, value: category.products },
                 published: true,
                 ...(options?.hasStock ? { stock: { quantity: { operator: Where.GT, value: 0 } } } : {}),
+                ...(options?.gender ? { tags: { operator: Where.IN, value: [options?.gender] } } : {}),
             },
             fields: [
                 'id',
@@ -2677,8 +3748,11 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
                 'tags',
                 'type',
                 'shoppingCount',
+                'gender',
+                'createdAt',
             ],
             ...(options?.limit ? { limits: { limit: options?.limit } } : {}),
+            options: { enableCount: false },
         });
         products.push(...productsData);
         return products;
@@ -2686,7 +3760,7 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
     async getId(id) {
         if (!Number.isNaN(+id))
             return id;
-        const { data } = await this.find({ filters: { firestoreId: id } });
+        const { data } = await this.find({ filters: { firestoreId: id }, options: { enableCount: false } });
         if (data?.[0]?.id)
             return data?.[0]?.id;
         throw new NotFoundError(`Category with id ${id} not found`);
@@ -2739,15 +3813,200 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
         });
         return plainData.metadata;
     }
+    async updateFilters(categoryId, { filters }) {
+        if ('action' in filters && filters.action === 'remove' && filters.value.length) {
+            for (let i = 0; i < filters.value.length; i++) {
+                await this.categoryFilterRepository.deleteByCategoryAndFilter(categoryId, filters.value[i].id);
+            }
+            return [];
+        }
+        if ('action' in filters && filters.action === 'merge' && filters.value.length) {
+            let filtersList = [];
+            const currentFilters = await this.categoryFilterRepository
+                .find({
+                filters: {
+                    categoryId,
+                },
+            })
+                .then((res) => res.data);
+            const currentFiltersId = currentFilters.map((f) => f.id);
+            const filtersUpdatedId = filters.value.map((f) => f.id);
+            const filterToBeDeleted = currentFiltersId.filter((c) => !filtersUpdatedId.includes(c));
+            const filterToBeInserted = filtersUpdatedId.filter((c) => !currentFiltersId.includes(c));
+            for (const filter of filterToBeDeleted) {
+                const index = currentFilters.findIndex((f) => f.id == filter);
+                if (index != -1) {
+                    currentFilters.splice(index, 1);
+                }
+                await this.categoryFilterRepository.deleteByCategoryAndFilter(categoryId, filter);
+            }
+            for (const filter of filterToBeInserted) {
+                const newCategoryFilter = await this.categoryFilterRepository.create({
+                    filterId: filter,
+                    categoryId,
+                });
+                filtersList.push(filter);
+            }
+            return filters.value;
+        }
+        if (Array.isArray(filters) && filters.length) {
+            await this.categoryFilterRepository.deleteByCategory(categoryId);
+            let filtersList = [];
+            for (let i = 0; i < filters.length; i++) {
+                const newCategoryFilter = await this.categoryFilterRepository.create({
+                    filterId: filters[i].id,
+                    categoryId,
+                });
+                filtersList.push(newCategoryFilter);
+            }
+            return filters;
+        }
+    }
+    async getChildren(parentId) {
+        const { category_tree } = await this.query('category_tree', ['id', 'name', 'parent_id'], {
+            args: {
+                type: 'category_tree_args',
+                value: { parentid: parentId },
+                required: true,
+            },
+        });
+        return category_tree.map((category) => Category.toInstance(category));
+    }
+    async isChild(id, parentId) {
+        const categoryTree = await this.getChildren(parentId);
+        return categoryTree.some((c) => c.id == id.toString());
+    }
+}
+
+class FilterHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, }, filterOptionRepository, categoryFilterRepository) {
+        super({
+            tableName: 'filter',
+            model: Filter,
+            endpoint,
+            authOptions,
+            interceptors,
+            fields: [
+                'id',
+                'description',
+                'slug',
+                'enabled',
+                { createdAt: { columnName: 'created_at' } },
+                { updatedAt: { columnName: 'updated_at' } },
+                {
+                    options: {
+                        columnName: 'options',
+                        foreignKeyColumn: { filterId: 'id' },
+                        fields: [
+                            'id',
+                            { filterId: { columnName: 'filter_id' } },
+                            'description',
+                            { createdAt: { columnName: 'created_at' } },
+                            { updatedAt: { columnName: 'updated_at' } },
+                        ],
+                    },
+                },
+            ],
+        });
+        this.filterOptionRepository = filterOptionRepository;
+        this.categoryFilterRepository = categoryFilterRepository;
+    }
+    async update(params) {
+        const { options, ...data } = params;
+        const filter = await super.update(data);
+        filter.options = await this.updateOptions(+data.id, { options });
+        return filter;
+    }
+    async updateOptions(filterId, { options }) {
+        if (!options)
+            return [];
+        if ('action' in options && options.action === 'remove' && options.value.length) {
+            for (let i = 0; i < options.value.length; i++) {
+                await this.filterOptionRepository.delete({ id: options.value[i].id });
+            }
+            return [];
+        }
+        if ('action' in options && options.action === 'merge' && options.value.length) {
+            let filterOptions = [];
+            for (let i = 0; i < options.value.length; i++) {
+                try {
+                    const hasFilter = await this.filterOptionRepository.get({ id: options.value[i].id });
+                    if (hasFilter)
+                        filterOptions.push(hasFilter);
+                }
+                catch (error) {
+                    const newOption = await this.filterOptionRepository.create({ ...options.value[i], filterId });
+                    filterOptions.push(newOption);
+                }
+            }
+            return filterOptions;
+        }
+        if (Array.isArray(options) && options.length) {
+            let filterOptions = [];
+            for (let i = 0; i < options.length; i++) {
+                try {
+                    const hasFilter = await this.filterOptionRepository.get({ id: options[i].id });
+                    if (hasFilter)
+                        filterOptions.push(hasFilter);
+                }
+                catch (error) {
+                    const newOption = await this.filterOptionRepository.create({ ...options[i], filterId });
+                    filterOptions.push(newOption);
+                }
+            }
+        }
+        return [];
+    }
+    async delete(params) {
+        const { data: categoryFilters } = await this.categoryFilterRepository.find({
+            filters: {
+                filterId: params.id,
+            },
+        });
+        if (categoryFilters.length)
+            throw new Error('Erro: o filtro está associado a uma ou mais categoria(s)');
+        await this.deleteOptions(+params.id);
+        await super.delete({ id: +params.id });
+        return;
+    }
+    async deleteOptions(filterId) {
+        await this.mutation('delete_filter_option', ['affected_rows'], {
+            where: {
+                type: 'filter_option_bool_exp',
+                required: true,
+                value: { filter_id: { _eq: filterId } },
+            },
+        });
+    }
+}
+
+class FilterOptionHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, }) {
+        super({
+            tableName: 'filter_option',
+            model: FilterOption,
+            endpoint,
+            authOptions,
+            interceptors,
+            fields: [
+                'id',
+                'description',
+                { filterId: { columnName: 'filter_id' } },
+                { createdAt: { columnName: 'created_at' } },
+                { updatedAt: { columnName: 'updated_at' } },
+            ],
+        });
+    }
 }
 
 class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
-    constructor(endpoint, authOptions) {
+    constructor({ endpoint, authOptions, interceptors, }) {
         super({
             tableName: 'product',
             model: ProductHasuraGraphQL,
             endpoint,
             authOptions,
+            interceptors,
             fields: [],
         });
         this.bindReviewToModel = (plain) => ({
@@ -2780,9 +4039,9 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
                         whoMustUse: data.who_must_use,
                         howToUse: data.how_to_use,
                         brand: data.brand_description,
+                        ingredients: data.ingredients,
                     }),
-                    bindFindFilter: (sentence) => {
-                        const filters = Object.values(sentence).shift();
+                    bindFindFilter: (filters) => {
                         return {
                             ...(filters?.description && { description: filters.description }),
                             ...(filters.differentials && { differentials: filters.differentials }),
@@ -2795,6 +4054,9 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
                             ...(filters.brand && {
                                 brand_description: filters.brand,
                             }),
+                            ...(filters.ingredients && {
+                                ingredients: filters.ingredients,
+                            }),
                         };
                     },
                     bindPersistData: (descriptionData) => ({
@@ -2805,6 +4067,7 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
                         }),
                         ...(descriptionData.howToUse && { how_to_use: descriptionData.howToUse }),
                         ...(descriptionData.brand && { brand_description: descriptionData.brand }),
+                        ...(descriptionData.ingredients && { ingredients: descriptionData.ingredients }),
                     }),
                 },
             },
@@ -2812,6 +4075,7 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             { whoMustUse: { columnName: 'who_must_use' } },
             { howToUse: { columnName: 'how_to_use' } },
             { brandDescription: { columnName: 'brand_description' } },
+            { ingredients: { columnName: 'ingredients' } },
             { hasVariants: { columnName: 'has_variants' } },
             {
                 images: {
@@ -2835,8 +4099,7 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
                         subscriberDiscountPercentage: data.subscriber_discount_percentage,
                         subscriberPrice: data.subscriber_price,
                     }),
-                    bindFindFilter: (sentence) => {
-                        const filters = Object.values(sentence).shift();
+                    bindFindFilter: (filters) => {
                         return {
                             ...((filters?.price || filters?.price === 0) && { price: filters.price }),
                             ...((filters.fullPrice || filters.fullPrice === 0) && { full_price: filters.fullPrice }),
@@ -2870,27 +4133,29 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
                     to: (value) => (isNil(value?.quantity) ? value : value?.quantity),
                 },
             },
+            { hasStock: { columnName: 'has_stock' } },
             'slug',
             'type',
             'video',
             'weight',
             'gender',
+            { intGender: { columnName: 'int_gender' } },
             { tags: { columnName: 'tags', type: HasuraGraphQLColumnType.Jsonb } },
+            { filters: { columnName: 'filters', type: HasuraGraphQLColumnType.Jsonb } },
             { isKit: { columnName: 'is_kit' } },
             { createdAt: { columnName: 'created_at' } },
             { updatedAt: { columnName: 'updated_at' } },
+            { rate: { columnName: 'rating' } },
+            { reviewsTotal: { columnName: 'reviews_total' } },
+            { shoppingCount: { columnName: 'shopping_count' } },
+            { categoryId: { columnName: 'category_id' } },
             {
-                rate: {
-                    columnName: 'reviews_aggregate',
-                    filters: {
-                        filters: { status: true },
-                        filterType: 'product_review_bool_exp',
-                    },
-                    fields: [{ aggregate: [{ avg: ['rate'] }] }],
-                    from: (value) => value.aggregate.avg.rate,
+                category: {
+                    columnName: 'category',
+                    foreignKeyColumn: { id: 'categoryId' },
+                    fields: ['id', 'name', 'reference', 'slug'],
                 },
             },
-            { shoppingCount: { columnName: 'shopping_count' } },
         ];
         this.fields = [
             ...commonFields,
@@ -2967,7 +4232,7 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
     }
     async get(identifiers) {
         const product = Number.isNaN(+identifiers.id)
-            ? (await this.find({ filters: { firestoreId: identifiers.id } })).data?.[0]
+            ? (await this.find({ filters: { firestoreId: identifiers.id }, options: { enableCount: false } })).data?.[0]
             : await super.get(identifiers);
         if (product.productId)
             throw new NotFoundError('Product not found, it is a variant');
@@ -2980,10 +4245,25 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             this.fields
                 .map((field) => (typeof field === 'string' ? field : Object.keys(field).shift()))
                 .filter((field) => field !== 'reviews');
+        if (options.options?.minimal?.includes('price'))
+            options.options?.minimal.push('price.price', 'price.fullPrice', 'price.subscriberPrice');
+        if (options.options?.maximum?.includes('price'))
+            options.options?.maximum.push('price.price', 'price.fullPrice', 'price.subscriberPrice');
+        options.options?.minimal?.splice(options.options?.minimal.indexOf('price'), 1);
+        options.options?.maximum?.splice(options.options?.maximum.indexOf('price'), 1);
         return super.find({
             ...options,
             filters: { ...filters, productId: { operator: Where.ISNULL } },
-            fields: bindFields,
+            fields: [
+                ...bindFields,
+                ...(bindFields.includes('price')
+                    ? [
+                        'subscriberPrice',
+                        'subscriberDiscountPercentage',
+                        'fullPrice',
+                    ]
+                    : []),
+            ],
         });
     }
     async getBySlug(slug) {
@@ -2991,9 +4271,13 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             filters: {
                 slug,
             },
+            fields: this.fields.map((field) => typeof field === 'string' ? field : Object.keys(field).shift()),
+            options: {
+                enableCount: false,
+            },
         });
         const product = result?.data?.shift();
-        product.reviews = await this.findReviewsByProduct(+product.id);
+        RoundProductPricesHelper.roundProductPrices(product);
         return product;
     }
     async update(params) {
@@ -3030,6 +4314,17 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             })),
         ], []);
     }
+    async findCatalog(params, mainGender) {
+        return this.find({
+            ...params,
+            filters: { ...params.filters, published: true },
+            orderBy: {
+                hasStock: 'desc',
+                ...(!mainGender ? {} : { intGender: mainGender === 'female' ? 'desc' : 'asc' }),
+                ...omit(params.orderBy, ['hasStock', 'intGender']),
+            },
+        });
+    }
     async updateCategories(productId, { categories }) {
         if ('action' in categories && categories.action === 'remove') {
             await this.mutation('delete_category_product', ['affected_rows'], {
@@ -3143,7 +4438,7 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
     async getId(id) {
         if (!Number.isNaN(+id))
             return id;
-        const { data } = await this.find({ filters: { firestoreId: id } });
+        const { data } = await this.find({ filters: { firestoreId: id }, options: { enableCount: false } });
         if (data?.[0]?.id)
             return data?.[0]?.id;
         throw new NotFoundError(`Product with id ${id} not found`);
@@ -3199,15 +4494,29 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
         });
         return data && data[0] && this.bindReviewToModel(data[0]);
     }
+    async cleanShoppingCountFromIds(ids) {
+        return await this.mutation('update_product', ['affected_rows'], {
+            where: {
+                value: { id: { _nin: ids } },
+                type: 'product_bool_exp',
+                required: true,
+            },
+            _set: {
+                value: { shopping_count: 0 },
+                type: 'product_set_input',
+            },
+        });
+    }
 }
 
 class VariantHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
-    constructor(endpoint, authOptions) {
+    constructor({ endpoint, authOptions, interceptors, }) {
         super({
             tableName: 'product',
             model: VariantHasuraGraphQL,
             endpoint,
             authOptions,
+            interceptors,
             fields: [
                 { id: { columnName: 'id', to: (value) => +value, from: (value) => value.toString() } },
                 { firestoreId: { columnName: 'firestore_id' } },
@@ -3243,12 +4552,12 @@ class VariantHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
                             };
                         },
                         bindPersistData: (priceData) => ({
-                            ...(priceData?.price >= 0 && { price: priceData.price }),
-                            ...(priceData.fullPrice >= 0 && { full_price: priceData.fullPrice }),
-                            ...(priceData.subscriberDiscountPercentage >= 0 && {
+                            ...((priceData?.price || 0) >= 0 && { price: priceData.price }),
+                            ...((priceData?.fullPrice || 0) >= 0 && { full_price: priceData.fullPrice }),
+                            ...((priceData?.subscriberDiscountPercentage || 0) >= 0 && {
                                 subscriber_discount_percentage: priceData.subscriberDiscountPercentage,
                             }),
-                            ...(priceData.subscriberPrice >= 0 && { subscriber_price: priceData.subscriberPrice }),
+                            ...((priceData?.subscriberPrice || 0) >= 0 && { subscriber_price: priceData.subscriberPrice }),
                         }),
                     },
                 },
@@ -3263,6 +4572,7 @@ class VariantHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
                         to: (value) => (isNil(value?.quantity) ? value : value?.quantity),
                     },
                 },
+                { hasStock: { columnName: 'has_stock' } },
                 'weight',
                 { name: { to: () => '', from: () => undefined } },
                 { hasVariants: { columnName: 'has_variants', to: () => false, from: () => undefined } },
@@ -3300,16 +4610,247 @@ class VariantHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
     async getId(id) {
         if (!Number.isNaN(+id))
             return id;
-        const { data } = await this.find({ filters: { firestoreId: id } });
+        const { data } = await this.find({ filters: { firestoreId: id }, options: { enableCount: false } });
         if (data?.[0]?.id)
             return data?.[0]?.id;
         throw new NotFoundError(`Product with id ${id} not found`);
     }
 }
 
+class WishlistHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, }, categoryFilterRepository) {
+        super({
+            tableName: 'category',
+            model: Wishlist,
+            endpoint,
+            authOptions,
+            interceptors,
+            fields: [
+                { id: { columnName: 'id', to: (value) => +value, from: (value) => value.toString() } },
+                { firestoreId: { columnName: 'firestore_id' } },
+                'name',
+                'description',
+                'image',
+                'published',
+                'shop',
+                { shops: { columnName: 'shops', type: HasuraGraphQLColumnType.Jsonb } },
+                'slug',
+                { brandCategory: { columnName: 'brand_category' } },
+                { brandCategoryBanner: { columnName: 'brand_banner' } },
+                { brandCategoryBannerMobile: { columnName: 'brand_banner_mobile' } },
+                { brandLogo: { columnName: 'brand_logo' } },
+                { brandCondition: { columnName: 'brand_condition' } },
+                {
+                    conditions: {
+                        columnName: 'tag_condition',
+                        type: HasuraGraphQLColumnType.Jsonb,
+                        from: (tags, row) => ({ brand: row.brand_condition, tags: Array.isArray(tags) ? tags : [] }),
+                        bindPersistData: (value) => {
+                            return {
+                                brand_condition: value.brand,
+                                tag_condition: value?.tags || [],
+                            };
+                        },
+                        bindFindFilter: (sentence) => {
+                            return {
+                                ...(sentence.brand ? { brand_condition: sentence.brand } : {}),
+                                ...(sentence.tags ? { tag_condition: sentence.tags } : {}),
+                            };
+                        },
+                    },
+                },
+                {
+                    filters: {
+                        columnName: 'filters',
+                        foreignKeyColumn: { filter_id: 'id' },
+                        fields: [{ filter: ['id', 'description', 'slug', 'enabled'] }],
+                        bindPersistData: (value) => ({
+                            filters: { data: value.map((filter) => ({ filter_id: filter.id })) },
+                        }),
+                        from: (filters) => filters?.map((filter) => filter?.filter) || [],
+                    },
+                },
+                { createdAt: { columnName: 'created_at' } },
+                { updatedAt: { columnName: 'updated_at' } },
+                {
+                    products: {
+                        columnName: 'products',
+                        fields: ['product_id'],
+                        from: (value) => value.map((product) => product.product_id.toString()),
+                        to: (productIds) => productIds.map((productId) => ({
+                            product_id: +productId,
+                        })),
+                    },
+                },
+                {
+                    metadata: {
+                        columnName: 'metadata',
+                        fields: ['title', 'description'],
+                        bindPersistData: (value) => ({
+                            metadata: { data: value },
+                        }),
+                    },
+                },
+                { isCollection: { columnName: 'is_collection' } },
+                { isWishlist: { columnName: 'is_wishlist' } },
+                'reference',
+                { parentId: { columnName: 'parent_id' } },
+                {
+                    parent: {
+                        columnName: 'parent',
+                        foreignKeyColumn: { id: 'parentId' },
+                        fields: ['id', 'name', 'reference', 'slug'],
+                    },
+                },
+                { personId: { columnName: 'person_id' } },
+            ],
+        });
+        this.categoryFilterRepository = categoryFilterRepository;
+    }
+    async create(params) {
+        const { metadata, ...data } = params;
+        return super.create({
+            ...data,
+            isWishlist: true,
+            isCollection: true,
+            brandCategory: false,
+            metadata: metadata || { description: data.description, title: data.name },
+        });
+    }
+    async get(identifiers) {
+        const data = await super.get(identifiers);
+        if (!data.isWishlist)
+            throw new NotFoundError(`Category with id ${identifiers.id} is not a wishlist`);
+        return data;
+    }
+    async update(params) {
+        const { products, id: checkId, metadata, filters, ...data } = params;
+        const plainData = this.paramsToPlain({ id: checkId });
+        const id = plainData.id;
+        const category = await super.update({ id, ...data, isWishlist: true, isCollection: true, brandCategory: false });
+        category.products = products && (await this.updateProducts(+id, { products }));
+        category.metadata = metadata && (await this.updateMetadata(+id, { metadata }));
+        return category;
+    }
+    async getWishlistBySlug(slug) {
+        if (!slug)
+            return;
+        const { data } = await this.find({
+            filters: {
+                slug,
+                isWishlist: { operator: Where.EQUALS, value: true },
+            },
+            options: {
+                enableCount: false,
+            },
+        });
+        if (!data.length)
+            throw new NotFoundError(`Wishlist with slug ${slug} not found`);
+        if (data.length > 1)
+            throw new DuplicatedResultsError('Query returned duplicated values');
+        return data.shift();
+    }
+    async getWishlistByPerson(personId) {
+        if (!personId)
+            return;
+        const { data } = await this.find({
+            filters: {
+                personId: { operator: Where.EQUALS, value: personId },
+                isWishlist: { operator: Where.EQUALS, value: true },
+            },
+            options: {
+                enableCount: false,
+            },
+        });
+        if (!data.length)
+            throw new NotFoundError(`Wishlists from person ${personId} not found`);
+        return data;
+    }
+    async updateProducts(categoryId, { products }) {
+        if ('action' in products && products.action === 'remove') {
+            await this.mutation('delete_category_product', ['affected_rows'], {
+                where: {
+                    type: 'category_product_bool_exp',
+                    required: true,
+                    value: { category_id: { _eq: categoryId } },
+                },
+            });
+            await this.categoryFilterRepository.deleteByCategory(categoryId);
+            return [];
+        }
+        const plainData = this.paramsToPlain({ products });
+        if (!plainData.products || plainData.products.length <= 0)
+            return [];
+        await this.mutation('delete_category_product', ['affected_rows'], {
+            where: {
+                type: 'category_product_bool_exp',
+                required: true,
+                value: { category_id: { _eq: categoryId } },
+            },
+        });
+        await this.categoryFilterRepository.deleteByCategory(categoryId);
+        await this.mutation('insert_category_product', ['affected_rows'], {
+            objects: {
+                type: '[category_product_insert_input!]',
+                required: true,
+                value: plainData.products.map((productId) => ({ category_id: categoryId, product_id: productId })),
+            },
+        });
+        return plainData.products;
+    }
+    async updateMetadata(categoryId, { metadata }) {
+        const plainData = this.paramsToPlain({ metadata });
+        if (!plainData.metadata)
+            return;
+        await this.mutation('update_category_metadata_by_pk', ['category_id'], {
+            pk_columns: {
+                value: { category_id: categoryId },
+                type: 'category_metadata_pk_columns_input',
+                required: true,
+            },
+            _set: {
+                value: omit(metadata, ['category_id']),
+                type: 'category_metadata_set_input',
+                required: true,
+            },
+        });
+        return plainData.metadata;
+    }
+    getCategoryBySlug(slug, _shop) {
+        return this.getWishlistBySlug(slug);
+    }
+    async getCategoryByShop(shop) {
+        if (!shop)
+            return;
+        const { data } = await this.find({
+            filters: {
+                shops: { operator: Where.IN, value: [shop] },
+                published: { operator: Where.EQUALS, value: true },
+                isWishlist: { operator: Where.EQUALS, value: true },
+            },
+            options: {
+                enableCount: false,
+            },
+        });
+        return data;
+    }
+    getCategoriesForHome(categoryIds, limit, gender) {
+        return;
+    }
+    mountCategory(category, options) {
+        return;
+    }
+    getChildren(parentId) {
+        return;
+    }
+    isChild(id, parentId) {
+        return;
+    }
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AccessoryImportances, Address, Area, Authentication, AuthenticationFirebaseAuthService, AxiosAdapter, Base, BaseModel, BeardProblems, BeardSizes, BeautyProductImportances, BeautyProfile, BeautyQuestionsHelper, BillingStatus, BodyProblems, BodyShapes, BodyTattoos, Buy2Win, Buy2WinFirestoreRepository, Category, CategoryFirestoreRepository, CategoryHasuraGraphQL, CategoryHasuraGraphQLRepository, Checkout, CheckoutFirestoreRepository, CheckoutSubscription, CheckoutSubscriptionFirestoreRepository, CheckoutTypes, Coupon, CouponFirestoreRepository, CouponSubtypes, CouponTypes, DuplicatedResultsError, Edition, EditionStatus, Exclusivities, FaceSkinOilinesses, FaceSkinProblems, FaceSkinTones, FamilyIncomes, FilterType, FragranceImportances, GenderDestination, HairColors, HairProblems, HairStrands, HairTypes, Home, HomeFirestoreRepository, InvalidArgumentError, KitProduct, KitProductHasuraGraphQL, Lead, LeadFirestoreRepository, LegacyOrderFirestoreRepository, LineItem, NotFoundError, OfficePosition, Order, OrderFirestoreRepository, OrderStatus, Payment, PaymentFirestoreRepository, PaymentType, Product, ProductFirestoreRepository, ProductHasuraGraphQL, ProductHasuraGraphQLRepository, ProductSpents, ProductVariantFirestoreRepository, ProductsIndex, QuestionsFilters, RecoveryPassword, Register, RegisterFirebaseAuthService, RequiredArgumentError, ShippingMethod, ShopMenu, ShopMenuFirestoreRepository, Shops, SignInMethods, SignOut, Status, Subscription, SubscriptionEditionFirestoreRepository, SubscriptionFirestoreRepository, SubscriptionPayment, SubscriptionPaymentFirestoreRepository, SubscriptionPlan, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, UnauthorizedError, UpdateOptionActions, User, UserAddress, UserAddressFirestoreRepository, UserAlreadyRegisteredError, UserBeautyProfileFirestoreRepository, UserFirestoreRepository, UserPaymentMethod, UserPaymentMethodFirestoreRepository, UserType, Variant, VariantHasuraGraphQL, VariantHasuraGraphQLRepository, WeakPasswordError, Where, chunk, get, is, isBoolean, isDate, isEmpty, isInteger, isNaN$1 as isNaN, isNil, isNumber, isObject, isString, isUUID, now, omit, parseDateTime, pick, set, withCreateFirestore, withCreateHasuraGraphQL, withCrudFirestore, withCrudHasuraGraphQL, withDeleteFirestore, withDeleteHasuraGraphQL, withFindFirestore, withFindHasuraGraphQL, withFirestore, withGetFirestore, withGetHasuraGraphQL, withHasuraGraphQL, withHelpers, withSubCollection, withUpdateFirestore, withUpdateHasuraGraphQL };
+export { AccessoryImportances, Address, Area, Authentication, AuthenticationFirebaseAuthService, AxiosAdapter, Base, BaseModel, BeardProblems, BeardSizes, BeautyProductImportances, BeautyProfile, BeautyQuestionsHelper, BillingStatus, BodyProblems, BodyShapes, BodyTattoos, Buy2Win, Buy2WinFirestoreRepository, CampaignDashboard, CampaignDashboardFirestoreRepository, CampaignHashtag, CampaignHashtagFirestoreRepository, Category, CategoryCollectionChildren, CategoryCollectionChildrenHasuraGraphQLRepository, CategoryFilter, CategoryFilterHasuraGraphQLRepository, CategoryFirestoreRepository, CategoryHasuraGraphQL, CategoryHasuraGraphQLRepository, Checkout, CheckoutFirestoreRepository, CheckoutSubscription, CheckoutSubscriptionFirestoreRepository, CheckoutTypes, ClassNameHelper, Coupon, CouponFirestoreRepository, CouponSubtypes, CouponTypes, Debug, DebugDecoratorHelper, DebugHelper, DebugNamespaces, DuplicatedResultsError, Edition, EditionStatus, Exclusivities, FaceSkinOilinesses, FaceSkinProblems, FaceSkinTones, FamilyIncomes, Filter, FilterHasuraGraphQLRepository, FilterOption, FilterOptionHasuraGraphQLRepository, FilterType, FragranceImportances, GenderDestination, HairColors, HairProblems, HairStrands, HairTypes, Home, HomeFirestoreRepository, InvalidArgumentError, KitProduct, KitProductHasuraGraphQL, Lead, LeadFirestoreRepository, LegacyOrderFirestoreRepository, LineItem, Log, Logger, NotFoundError, OfficePosition, Order, OrderFirestoreRepository, OrderStatus, Payment, PaymentFirestoreRepository, PaymentType, Product, ProductFirestoreRepository, ProductHasuraGraphQL, ProductHasuraGraphQLRepository, ProductSpents, ProductVariantFirestoreRepository, ProductsIndex, QuestionsFilters, RecoveryPassword, ReflectHelper, Register, RegisterFirebaseAuthService, RequiredArgumentError, RoundProductPricesHelper, ShippingMethod, ShopMenu, ShopMenuFirestoreRepository, ShopSettings, ShopSettingsFirestoreRepository, Shops, SignInMethods, SignOut, Status, Subscription, SubscriptionEditionFirestoreRepository, SubscriptionFirestoreRepository, SubscriptionPayment, SubscriptionPaymentFirestoreRepository, SubscriptionPlan, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, Trace, UnauthorizedError, UpdateOptionActions, User, UserAddress, UserAddressFirestoreRepository, UserAlreadyRegisteredError, UserBeautyProfileFirestoreRepository, UserFirestoreRepository, UserPaymentMethod, UserPaymentMethodFirestoreRepository, UserType, Variant, VariantHasuraGraphQL, VariantHasuraGraphQLRepository, WeakPasswordError, Where, Wishlist, WishlistHasuraGraphQLRepository, is, isDebuggable, isUUID, parseDateTime, withCreateFirestore, withCreateHasuraGraphQL, withCrudFirestore, withCrudHasuraGraphQL, withDeleteFirestore, withDeleteHasuraGraphQL, withFindFirestore, withFindHasuraGraphQL, withFirestore, withGetFirestore, withGetHasuraGraphQL, withHasuraGraphQL, withHelpers, withSubCollection, withUpdateFirestore, withUpdateHasuraGraphQL };
 //# sourceMappingURL=infrab4a-connect.mjs.map