@infrab4a/connect 4.0.0 → 4.0.1-beta.0

package/fesm2020/infrab4a-connect.mjs

@@ -1,4856 +0,0 @@
-import 'reflect-metadata';
-import { plainToInstance, instanceToPlain, Expose, Type } from 'class-transformer';
-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 { 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';
-
-class BaseModel {
-    get identifier() {
-        const fields = this.constructor.identifiersFields.filter((field) => field !== 'identifier');
-        const data = this;
-        return fields.reduce((object, field) => ({ ...object, [field]: data[field] }), {});
-    }
-    get identifiersFields() {
-        return this.constructor.identifiersFields;
-    }
-    constructor(args) {
-        Object.assign(this, args);
-    }
-    static toInstance(data) {
-        return plainToInstance(this, data || {});
-    }
-    static isModel(value) {
-        return value instanceof this;
-    }
-    toPlain() {
-        return instanceToPlain(this);
-    }
-}
-
-var Where;
-(function (Where) {
-    Where["EQUALS"] = "==";
-    Where["NOTEQUALS"] = "!=";
-    Where["GT"] = ">";
-    Where["GTE"] = ">=";
-    Where["IN"] = "in";
-    Where["NOTIN"] = "not in";
-    Where["LT"] = "<";
-    Where["LTE"] = "<=";
-    Where["LIKE"] = "like";
-    Where["NOTLIKE"] = "not like";
-    Where["ISNULL"] = "is null";
-    Where["ISNOTNULL"] = "is not null";
-})(Where || (Where = {}));
-
-var UpdateOptionActions;
-(function (UpdateOptionActions) {
-    UpdateOptionActions["UPDATE"] = "update";
-    UpdateOptionActions["MERGE"] = "merge";
-    UpdateOptionActions["REMOVE"] = "remove";
-    UpdateOptionActions["REMOVE_FIELD"] = "removeField";
-    UpdateOptionActions["NULL"] = "null";
-})(UpdateOptionActions || (UpdateOptionActions = {}));
-
-var AccessoryImportances;
-(function (AccessoryImportances) {
-    AccessoryImportances["NOT_INTERESTED"] = "N\u00E3o tenho interesse";
-    AccessoryImportances["LIKE_RARELY_USE"] = "Gosto, mas uso poucos";
-    AccessoryImportances["LIKE_ALWAYS_FOLLOW_FASHION"] = "Gosto muito de acess\u00F3rios e sempre procuro acompanhar a moda";
-})(AccessoryImportances || (AccessoryImportances = {}));
-
-var Area;
-(function (Area) {
-    Area["GP"] = "Geral";
-    Area["CRM"] = "CRM";
-    Area["MediaProd"] = "Media Production";
-    Area["Tech"] = "Tecnologia";
-    Area["Transactional"] = "Transacional";
-    Area["Operations"] = "Opera\u00E7\u00F5es";
-    Area["Sales"] = "Comercial";
-    Area["Finantial"] = "Financeiro";
-    Area["HR"] = "RH";
-})(Area || (Area = {}));
-
-var BeardProblems;
-(function (BeardProblems) {
-    BeardProblems["NO_PROBLEMS"] = "Sem problemas";
-    BeardProblems["DRY"] = "Barba Seca";
-    BeardProblems["OILY"] = "Barba Oleaosa";
-    BeardProblems["DANCRUFF"] = "Barba com Caspa";
-    BeardProblems["INGROWN_HAIRS"] = "P\u00EAlos Encravados";
-    BeardProblems["DOESNT_GROW"] = "N\u00E3o Cresce";
-    BeardProblems["SPARSE_BEARD"] = "Barba Rala";
-})(BeardProblems || (BeardProblems = {}));
-
-var BeardSizes;
-(function (BeardSizes) {
-    BeardSizes["BIG"] = "Grande";
-    BeardSizes["MEDIUM"] = "M\u00E9dia";
-    BeardSizes["SHORT"] = "Curta";
-    BeardSizes["MUSTACHE"] = "Bigode";
-    BeardSizes["NOTHING"] = "Sem Barba";
-})(BeardSizes || (BeardSizes = {}));
-
-var BeautyProductImportances;
-(function (BeautyProductImportances) {
-    BeautyProductImportances["KNOW_LITTLE_ABOUT"] = "Conhe\u00E7o bem pouco de produtos de beleza e rotinas de cuidados";
-    BeautyProductImportances["ALREADY_BOUGHT_NOTHING_SPECIALIZED"] = "J\u00E1 comprei alguns produtos b\u00E1sicos para cuidar de mim, mas nada muito especializado";
-    BeautyProductImportances["GOOD_CARE_MYSELF"] = "Me considero um homem que se cuida bem. Conhe\u00E7o sobre produtos especializados e me preocupo em ter uma rotina de cuidados";
-    BeautyProductImportances["PERSONAL_CARE_EXPERT"] = "Sou um expert em cuidados pessoais";
-})(BeautyProductImportances || (BeautyProductImportances = {}));
-
-var BodyProblems;
-(function (BodyProblems) {
-    BodyProblems["NO_WORRIES"] = "Sem preocupa\u00E7\u00F5es";
-    BodyProblems["FLACCIDITY"] = "Flacidez";
-    BodyProblems["LOCALIZED_FAT"] = "Gordura Localizada";
-    BodyProblems["STRETCH_MARKS"] = "Estrias";
-    BodyProblems["SENSITIVE_SKIN"] = "Pele Sens\u00EDvel";
-    BodyProblems["DRY_SKIN"] = "Pele Seca";
-    BodyProblems["OILY_ACNE"] = "Oleosa/Acne";
-    BodyProblems["SKIN_FRECKLES"] = "Pele com Sardas";
-    BodyProblems["PHOTOSENSITIVE_SKIN"] = "Pele Fotossens\u00EDvel";
-})(BodyProblems || (BodyProblems = {}));
-
-var BodyShapes;
-(function (BodyShapes) {
-    BodyShapes["LEAN"] = "Magro";
-    BodyShapes["REGULAR"] = "Regular";
-    BodyShapes["OVERWEIGHT"] = "Acima do Peso";
-    BodyShapes["ATHLETIC"] = "Atl\u00E9tico";
-    BodyShapes["MUSCULAR"] = "Musculoso";
-})(BodyShapes || (BodyShapes = {}));
-
-var BodyTattoos;
-(function (BodyTattoos) {
-    BodyTattoos["NONE"] = "Nenhuma";
-    BodyTattoos["HAS_DOESNT_CARE"] = "Tenho mas n\u00E3o cuido";
-    BodyTattoos["HAS_CARE_LOT"] = "Tenho e cuido bastante";
-})(BodyTattoos || (BodyTattoos = {}));
-
-var FaceSkinOilinesses;
-(function (FaceSkinOilinesses) {
-    FaceSkinOilinesses["DRY"] = "Seca";
-    FaceSkinOilinesses["OILY"] = "Oleaosa";
-    FaceSkinOilinesses["MIXED"] = "Mista";
-    FaceSkinOilinesses["NORMAL"] = "Normal";
-    FaceSkinOilinesses["DONT_KNOW"] = "Eu n\u00E3o sei como dizer";
-})(FaceSkinOilinesses || (FaceSkinOilinesses = {}));
-
-var FaceSkinProblems;
-(function (FaceSkinProblems) {
-    FaceSkinProblems["NO_PROBLEMS"] = "Sem problemas";
-    FaceSkinProblems["DARK_CIRCLES"] = "Olheiras";
-    FaceSkinProblems["WRINKLES"] = "Rugas";
-    FaceSkinProblems["BLACKHEADS_PIMPLES"] = "Cravos e Espinhas";
-    FaceSkinProblems["STAINS"] = "Manchas";
-    FaceSkinProblems["FRECKLES"] = "Sardas";
-    FaceSkinProblems["SENSITIVE"] = "Sens\u00EDvel";
-    FaceSkinProblems["PHOTOSENSITIVE"] = "Fotossens\u00EDvel";
-})(FaceSkinProblems || (FaceSkinProblems = {}));
-
-var FaceSkinTones;
-(function (FaceSkinTones) {
-    FaceSkinTones["VERY_CLEAR"] = "Muito Clara";
-    FaceSkinTones["CLEAR"] = "Clara";
-    FaceSkinTones["MEDIUM_LIGHT"] = "Clara M\u00E9dia";
-    FaceSkinTones["MEDIUM_DARK"] = "Escura M\u00E9dia";
-    FaceSkinTones["DARK"] = "Escura";
-    FaceSkinTones["VERY_DARK"] = "Muito Escura";
-})(FaceSkinTones || (FaceSkinTones = {}));
-
-var FamilyIncomes;
-(function (FamilyIncomes) {
-    FamilyIncomes["UNTIL_3000"] = "At\u00E9 R$3.000";
-    FamilyIncomes["SINCE_3001_TO_7000"] = "De R$3.001 a R$7.000";
-    FamilyIncomes["SINCE_7001_TO_10000"] = "De R$7.001 a R$10.000";
-    FamilyIncomes["SINCE_10001_TO_15000"] = "De R$10.001 a R$15.000";
-    FamilyIncomes["GRAN_THAN_15000"] = "Mais de R$15.000";
-    FamilyIncomes["NOW_ANSWER"] = "Prefiro nao responder";
-})(FamilyIncomes || (FamilyIncomes = {}));
-
-var FragranceImportances;
-(function (FragranceImportances) {
-    FragranceImportances["NOT_INTERESTED"] = "N\u00E3o tenho interesse";
-    FragranceImportances["LIKE_ALWAYS_USE_SAME"] = "Gosto de perfumes, mas uso sempre os mesmos";
-    FragranceImportances["LIKE_INNOVATE"] = "Gosto de inovar e conhecer novas fragr\u00E2ncias";
-})(FragranceImportances || (FragranceImportances = {}));
-
-var HairColors;
-(function (HairColors) {
-    HairColors["BLACK"] = "Preto";
-    HairColors["DARK_BROWN"] = "Castanho Escuro";
-    HairColors["LIGHT_BROWN"] = "Castanho Claro";
-    HairColors["DARK_BLONDE"] = "Loiro Escuro";
-    HairColors["LIGHT_BLONDE"] = "Loiro Claro";
-    HairColors["WHITE_GRAY"] = "Branco/Grisalho";
-    HairColors["REDHEAD"] = "Ruivo";
-    HairColors["OTHER"] = "RuiOutroo";
-})(HairColors || (HairColors = {}));
-
-var HairProblems;
-(function (HairProblems) {
-    HairProblems["NO_PROBLEMS"] = "Sem problemas";
-    HairProblems["DANCRUFF"] = "Caspa";
-    HairProblems["LOSS"] = "Queda";
-    HairProblems["OILY"] = "Oleosidade";
-    HairProblems["DRYNESS"] = "Ressecamento";
-    HairProblems["CHEMICAL"] = "Quimica";
-    HairProblems["WHITE_HAIR"] = "Cabelos Brancos";
-    HairProblems["REBEL_WIRES"] = "Fios Rebeldes";
-})(HairProblems || (HairProblems = {}));
-
-var HairStrands;
-(function (HairStrands) {
-    HairStrands["NORMAL"] = "Fio Normal";
-    HairStrands["DRY"] = "Fio Seco";
-    HairStrands["OILY"] = "Fio Oleoso";
-    HairStrands["MIXED"] = "Fio Misto";
-    HairStrands["FINE"] = "Fio Fino";
-    HairStrands["THICK"] = "Fio Grosso";
-})(HairStrands || (HairStrands = {}));
-
-var HairTypes;
-(function (HairTypes) {
-    HairTypes["Smooth"] = "Liso";
-    HairTypes["WAVY"] = "Ondulado";
-    HairTypes["CURLY"] = "Cacheado";
-    HairTypes["FRIZZY"] = "Crespo";
-    HairTypes["BALD"] = "Sou careca";
-})(HairTypes || (HairTypes = {}));
-
-var OfficePosition;
-(function (OfficePosition) {
-    OfficePosition["Intern"] = "Estagi\u00E1rio";
-    OfficePosition["Analyst"] = "Analista";
-    OfficePosition["Manager"] = "Gerente";
-    OfficePosition["Director"] = "Diretor";
-})(OfficePosition || (OfficePosition = {}));
-
-var ProductSpents;
-(function (ProductSpents) {
-    ProductSpents["UNTIL_50"] = "At\u00E9 R$50";
-    ProductSpents["SINCE_51_TO_100"] = "De R$51 a R$100";
-    ProductSpents["SINCE_101_TO_200"] = "De R$101 a R$200";
-    ProductSpents["SINCE_201_TO_300"] = "De R$201 a R$300";
-    ProductSpents["GRAN_THAN_300"] = "Mais de R$300";
-    ProductSpents["NOW_ANSWER"] = "Prefiro nao responder";
-})(ProductSpents || (ProductSpents = {}));
-
-var UserType;
-(function (UserType) {
-    UserType["B2C"] = "Cliente Transacional";
-    UserType["GlamGirl"] = "Glamgirl";
-    UserType["MensBoy"] = "Mensboy";
-    UserType["B2B"] = "Company";
-    UserType["Collaborator"] = "Funcion\u00E1rio";
-    UserType["Influencer"] = "Influencer";
-})(UserType || (UserType = {}));
-
-var BillingStatus;
-(function (BillingStatus) {
-    BillingStatus["PAYED"] = "PAGO";
-})(BillingStatus || (BillingStatus = {}));
-
-var EditionStatus;
-(function (EditionStatus) {
-    EditionStatus["ALLOCATION_WAITING"] = "Aguardando aloca\u00E7\u00E3o";
-    EditionStatus["SHIPPED"] = "Enviado";
-})(EditionStatus || (EditionStatus = {}));
-
-var PaymentType;
-(function (PaymentType) {
-    PaymentType["AQUISITION"] = "Aquisi\u00E7\u00E3o";
-    PaymentType["RENEWAL"] = "Renova\u00E7\u00E3o";
-    PaymentType["FREIGHT"] = "mudan\u00E7a de endere\u00E7o, Frete";
-})(PaymentType || (PaymentType = {}));
-
-var Status;
-(function (Status) {
-    Status["ACTIVE"] = "active";
-    Status["CANCELLED"] = "Cancelado";
-})(Status || (Status = {}));
-
-class Edition extends BaseModel {
-    static get identifiersFields() {
-        return ['id', 'subscriptionId'];
-    }
-}
-
-class Payment extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-__decorate([
-    Expose({ name: 'refuse_reason' }),
-    __metadata("design:type", String)
-], Payment.prototype, "refuseReason", void 0);
-__decorate([
-    Expose({ name: 'status_reason' }),
-    __metadata("design:type", String)
-], Payment.prototype, "statusReason", void 0);
-__decorate([
-    Expose({ name: 'acquirer_response_code' }),
-    __metadata("design:type", String)
-], Payment.prototype, "acquirerResponseCode", void 0);
-__decorate([
-    Expose({ name: 'acquirer_name' }),
-    __metadata("design:type", String)
-], Payment.prototype, "acquirerName", void 0);
-__decorate([
-    Expose({ name: 'acquirer_id' }),
-    __metadata("design:type", String)
-], Payment.prototype, "acquirerId", void 0);
-__decorate([
-    Expose({ name: 'authorization_code' }),
-    __metadata("design:type", String)
-], Payment.prototype, "authorizationCode", void 0);
-__decorate([
-    Expose({ name: 'soft_descriptor' }),
-    __metadata("design:type", String)
-], Payment.prototype, "softDescriptor", void 0);
-__decorate([
-    Expose({ name: 'date_created' }),
-    __metadata("design:type", String)
-], Payment.prototype, "dateCreated", void 0);
-__decorate([
-    Expose({ name: 'date_updated' }),
-    __metadata("design:type", String)
-], Payment.prototype, "dateUpdated", void 0);
-__decorate([
-    Expose({ name: 'authorized_amount' }),
-    __metadata("design:type", Number)
-], Payment.prototype, "authorizedAmount", void 0);
-__decorate([
-    Expose({ name: 'paid_amount' }),
-    __metadata("design:type", Number)
-], Payment.prototype, "paidAmount", void 0);
-__decorate([
-    Expose({ name: 'refunded_amount' }),
-    __metadata("design:type", Number)
-], Payment.prototype, "refundedAmount", void 0);
-__decorate([
-    Expose({ name: 'card_holder_name' }),
-    __metadata("design:type", String)
-], Payment.prototype, "cardHolderName", void 0);
-__decorate([
-    Expose({ name: 'card_last_digits' }),
-    __metadata("design:type", String)
-], Payment.prototype, "cardLastDigits", void 0);
-__decorate([
-    Expose({ name: 'card_first_digits' }),
-    __metadata("design:type", String)
-], Payment.prototype, "cardFirstDigits", void 0);
-__decorate([
-    Expose({ name: 'card_brand' }),
-    __metadata("design:type", String)
-], Payment.prototype, "cardBrand", void 0);
-__decorate([
-    Expose({ name: 'card_pin_mode' }),
-    __metadata("design:type", String)
-], Payment.prototype, "cardPinMode", void 0);
-__decorate([
-    Expose({ name: 'card_magstripe_fallback' }),
-    __metadata("design:type", Boolean)
-], Payment.prototype, "cardMagstripeFallback", void 0);
-__decorate([
-    Expose({ name: 'cvm_pin' }),
-    __metadata("design:type", Boolean)
-], Payment.prototype, "cvmPin", void 0);
-__decorate([
-    Expose({ name: 'postback_url' }),
-    __metadata("design:type", String)
-], Payment.prototype, "postbackUrl", void 0);
-__decorate([
-    Expose({ name: 'payment_method' }),
-    __metadata("design:type", String)
-], Payment.prototype, "paymentMethod", void 0);
-__decorate([
-    Expose({ name: 'capture_method' }),
-    __metadata("design:type", String)
-], Payment.prototype, "captureMethod", void 0);
-__decorate([
-    Expose({ name: 'antifraud_score' }),
-    __metadata("design:type", String)
-], Payment.prototype, "antifraudScore", void 0);
-__decorate([
-    Expose({ name: 'boleto_url' }),
-    __metadata("design:type", String)
-], Payment.prototype, "boletoUrl", void 0);
-__decorate([
-    Expose({ name: 'boleto_barcode' }),
-    __metadata("design:type", String)
-], Payment.prototype, "boletoBarcode", void 0);
-__decorate([
-    Expose({ name: 'boleto_expiration_date' }),
-    __metadata("design:type", String)
-], Payment.prototype, "boletoExpirationDate", void 0);
-__decorate([
-    Expose({ name: 'subscription_id' }),
-    __metadata("design:type", String)
-], Payment.prototype, "subscriptionId", void 0);
-__decorate([
-    Expose({ name: 'split_rules' }),
-    __metadata("design:type", String)
-], Payment.prototype, "splitRules", void 0);
-__decorate([
-    Expose({ name: 'antifraud_metadata' }),
-    __metadata("design:type", Object)
-], Payment.prototype, "antifraudMetadata", void 0);
-__decorate([
-    Expose({ name: 'reference_key' }),
-    __metadata("design:type", String)
-], Payment.prototype, "referenceKey", void 0);
-__decorate([
-    Expose({ name: 'local_transaction_id' }),
-    __metadata("design:type", String)
-], Payment.prototype, "localTransactionId", void 0);
-__decorate([
-    Expose({ name: 'local_time' }),
-    __metadata("design:type", String)
-], Payment.prototype, "localTime", void 0);
-__decorate([
-    Expose({ name: 'fraud_covered' }),
-    __metadata("design:type", Boolean)
-], Payment.prototype, "fraudCovered", void 0);
-__decorate([
-    Expose({ name: 'fraud_reimbursed' }),
-    __metadata("design:type", String)
-], Payment.prototype, "fraudReimbursed", void 0);
-__decorate([
-    Expose({ name: 'order_id' }),
-    __metadata("design:type", String)
-], Payment.prototype, "orderId", void 0);
-__decorate([
-    Expose({ name: 'risk_level' }),
-    __metadata("design:type", String)
-], Payment.prototype, "riskLevel", void 0);
-__decorate([
-    Expose({ name: 'receipt_url' }),
-    __metadata("design:type", String)
-], Payment.prototype, "receiptUrl", void 0);
-__decorate([
-    Expose({ name: 'private_label' }),
-    __metadata("design:type", String)
-], Payment.prototype, "privateLabel", void 0);
-__decorate([
-    Expose({ name: 'pix_qr_code' }),
-    __metadata("design:type", String)
-], Payment.prototype, "pixQrCode", void 0);
-__decorate([
-    Expose({ name: 'pix_expiration_date' }),
-    __metadata("design:type", String)
-], Payment.prototype, "pixExpirationDate", void 0);
-
-class SubscriptionPayment extends BaseModel {
-    static get identifiersFields() {
-        return ['id', 'subscriptionId'];
-    }
-}
-__decorate([
-    Type(() => Payment),
-    __metadata("design:type", Payment)
-], SubscriptionPayment.prototype, "payment", void 0);
-
-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);
-
-function is(value) {
-    return 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) {
-        Object.assign(this, ...args);
-    }
-}
-
-const parseDateTime = (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))
-        return value;
-    const date = parseISO(value);
-    if (isNaN(date.getTime()))
-        return value;
-    return date;
-};
-
-var CheckoutTypes;
-(function (CheckoutTypes) {
-    CheckoutTypes[CheckoutTypes["ECOMMERCE"] = 1] = "ECOMMERCE";
-    CheckoutTypes[CheckoutTypes["SUBSCRIPTION"] = 2] = "SUBSCRIPTION";
-    CheckoutTypes[CheckoutTypes["ALL"] = 3] = "ALL";
-})(CheckoutTypes || (CheckoutTypes = {}));
-
-var CouponTypes;
-(function (CouponTypes) {
-    CouponTypes[CouponTypes["ABSOLUTE"] = 1] = "ABSOLUTE";
-    CouponTypes[CouponTypes["PERCENTAGE"] = 2] = "PERCENTAGE";
-    // FINANCIAL = 1,
-    // PRODUCT,
-    // GIFTCARD,
-    // VOUCHER,
-})(CouponTypes || (CouponTypes = {}));
-
-var CouponSubtypes;
-(function (CouponSubtypes) {
-    CouponSubtypes[CouponSubtypes["ABSOLUTE"] = 1] = "ABSOLUTE";
-    CouponSubtypes[CouponSubtypes["PERCENTAGE"] = 2] = "PERCENTAGE";
-})(CouponSubtypes || (CouponSubtypes = {}));
-
-var Exclusivities;
-(function (Exclusivities) {
-    Exclusivities[Exclusivities["ALL_USERS"] = 1] = "ALL_USERS";
-    Exclusivities[Exclusivities["SPECIFIC_USER"] = 2] = "SPECIFIC_USER";
-    Exclusivities[Exclusivities["COLLABORATORS"] = 3] = "COLLABORATORS";
-    Exclusivities[Exclusivities["ACTIVE_SUBSCRIBER"] = 4] = "ACTIVE_SUBSCRIBER";
-    Exclusivities[Exclusivities["INACTIVE_SUBSCRIBER"] = 5] = "INACTIVE_SUBSCRIBER";
-    Exclusivities[Exclusivities["NON_SUBSCRIBER"] = 6] = "NON_SUBSCRIBER";
-})(Exclusivities || (Exclusivities = {}));
-
-const COUPON_EXPIRATION = +1000 * 60 * 60 * 24 * 30;
-class Coupon extends BaseModel {
-    get isInfluencer() {
-        return !isNil(this.influencerEmail);
-    }
-    static get identifiersFields() {
-        return ['id'];
-    }
-    static createCoupon(userId) {
-        return this.toInstance({
-            nickname: `${Date.now()}`,
-            checkoutType: CheckoutTypes.ECOMMERCE,
-            discount: {
-                subscriber: {
-                    type: CouponTypes.ABSOLUTE,
-                    value: 10,
-                },
-                non_subscriber: {
-                    type: CouponTypes.ABSOLUTE,
-                    value: 10,
-                },
-                subscription: {
-                    type: CouponTypes.ABSOLUTE,
-                    value: 10,
-                },
-            },
-            user: userId,
-            createdAt: new Date(Date.now()),
-            beginAt: new Date(Date.now()),
-            expiresIn: new Date(Date.now() + COUPON_EXPIRATION),
-        });
-    }
-}
-
-class SubscriptionPlan extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class BeautyProfile extends BaseModel {
-    toPlain() {
-        const plain = super.toPlain();
-        delete plain.id;
-        return plain;
-    }
-    static get identifiersFields() {
-        return ['id', 'userId'];
-    }
-}
-
-class User extends BaseModel {
-    static toInstance(data) {
-        const instance = super.toInstance(data);
-        if (!isNil(data.firstName))
-            instance.displayName = `${data.firstName}${!isNil(data.lastName) ? ` ${data.lastName}` : ''}`;
-        return instance;
-    }
-    toPlain() {
-        const plain = super.toPlain();
-        delete plain.beautyProfile;
-        return plain;
-    }
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-__decorate([
-    Type(() => BeautyProfile),
-    __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'];
-    }
-}
-__decorate([
-    Type(() => User),
-    __metadata("design:type", User)
-], Subscription.prototype, "user", void 0);
-__decorate([
-    Type(() => SubscriptionPlan),
-    __metadata("design:type", SubscriptionPlan)
-], Subscription.prototype, "subscriptionPlan", void 0);
-__decorate([
-    Type(() => UserAddress),
-    __metadata("design:type", UserAddress)
-], Subscription.prototype, "shippingAddress", void 0);
-__decorate([
-    Type(() => UserAddress),
-    __metadata("design:type", UserAddress)
-], Subscription.prototype, "billingAddress", void 0);
-__decorate([
-    Type(() => Coupon),
-    __metadata("design:type", Coupon)
-], Subscription.prototype, "coupon", void 0);
-__decorate([
-    Type(() => Edition),
-    __metadata("design:type", Array)
-], Subscription.prototype, "editions", void 0);
-__decorate([
-    Type(() => SubscriptionPayment),
-    __metadata("design:type", Array)
-], Subscription.prototype, "payment", void 0);
-
-class UserPaymentMethod extends BaseModel {
-    static get identifiersFields() {
-        return ['id', 'userId'];
-    }
-}
-
-class Lead extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class UnauthorizedError extends CustomError {
-    constructor(message) {
-        super(message);
-    }
-}
-
-var SignInMethods;
-(function (SignInMethods) {
-    SignInMethods["EMAIL_PASSWORD"] = "email_password";
-    SignInMethods["GOOGLE"] = "google";
-})(SignInMethods || (SignInMethods = {}));
-class Authentication {
-    constructor(authService, userRepository) {
-        this.authService = authService;
-        this.userRepository = userRepository;
-    }
-    async signIn({ email, password }, signInMethod) {
-        const method = this.getServiceByMethod(signInMethod);
-        const userAuth = await this.authService[method]({ email, password });
-        const user = this.userRepository.get({ id: userAuth.id });
-        if (!isNil(user))
-            return user;
-        if (/^.+@b4a.com.br$/.test(userAuth.email))
-            return this.createsUserByCredential(userAuth);
-        throw new UnauthorizedError('Invalid credentials');
-    }
-    getServiceByMethod(signInMethod) {
-        return signInMethod === SignInMethods.EMAIL_PASSWORD ? 'signInWithEmailAndPassword' : 'signInWithGoogle';
-    }
-    async createsUserByCredential(user) {
-        const [firstName, lastName] = user.displayName?.split(/\s/);
-        const person = User.toInstance({
-            ...user,
-            cpf: '',
-            birthday: new Date(),
-            firstName,
-            lastName,
-            acceptsNewsletter: false,
-            area: Area.Transactional,
-            officePosition: OfficePosition.Intern,
-            type: UserType.Collaborator,
-        });
-        return this.userRepository.create(person);
-    }
-}
-
-class UserAlreadyRegisteredError extends CustomError {
-    constructor(message) {
-        super(message);
-    }
-}
-
-class WeakPasswordError extends CustomError {
-    constructor(message = 'Weak password') {
-        super(message);
-    }
-}
-
-class Register {
-    constructor(registerService, userRepository) {
-        this.registerService = registerService;
-        this.userRepository = userRepository;
-    }
-    async register(params) {
-        const email = params.email.toLocaleLowerCase();
-        const displayName = `${params.firstName} ${params.lastName}`;
-        if (await this.userRepository.checkIfExistsByField('cpf', params.cpf))
-            throw new UserAlreadyRegisteredError(`Usuário com CPF ${params.cpf} já registrado.`);
-        if (await this.userRepository.checkIfExistsByField('email', params.email))
-            throw new UserAlreadyRegisteredError(`Usuário com e-mail ${params.email} já registrado.`);
-        const auth = await this.registerService.register({
-            birthday: params.birthday,
-            email,
-            firstName: params.firstName,
-            lastName: params.lastName,
-            cpf: params.cpf,
-            displayName,
-            phone: params.phone,
-            password: params.password,
-        });
-        delete params.password;
-        const user = await this.userRepository.create({
-            ...params,
-            id: auth.id,
-            email,
-            displayName,
-            type: UserType.B2C,
-            dateCreated: new Date(),
-            dateModified: new Date(),
-        });
-        return user;
-    }
-}
-
-class SignOut {
-    constructor(authService) {
-        this.authService = authService;
-    }
-    async signOut() {
-        await this.authService.signOut();
-    }
-}
-
-class RecoveryPassword {
-    constructor(authService) {
-        this.authService = authService;
-    }
-    async sendEmail(email) {
-        await this.authService.sendPasswordResetEmail(email);
-    }
-}
-
-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) {
-    GenderDestination["FEMALE"] = "female";
-    GenderDestination["MALE"] = "male";
-    GenderDestination["UNISEX"] = "unisex";
-})(GenderDestination || (GenderDestination = {}));
-
-var Shops;
-(function (Shops) {
-    Shops["MENSMARKET"] = "mensmarket";
-    Shops["GLAMSHOP"] = "Glamshop";
-    Shops["GLAMPOINTS"] = "Glampoints";
-    Shops["ALL"] = "ALL";
-})(Shops || (Shops = {}));
-
-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 Variant extends BaseModel {
-    static get identifiersFields() {
-        return ['id', 'productId'];
-    }
-}
-
-class Wishlist extends Category {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class Buy2Win extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-__decorate([
-    Type(() => Category),
-    __metadata("design:type", Array)
-], Buy2Win.prototype, "categories", void 0);
-
-class CampaignDashboard extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class CampaignHashtag extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class LineItem extends Product {
-}
-
-class ShippingMethod extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class Checkout extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-__decorate([
-    Type(() => LineItem),
-    __metadata("design:type", Array)
-], Checkout.prototype, "lineItems", void 0);
-__decorate([
-    Type(() => User),
-    __metadata("design:type", User)
-], Checkout.prototype, "user", void 0);
-__decorate([
-    Type(() => UserAddress),
-    __metadata("design:type", UserAddress)
-], Checkout.prototype, "shippingAddress", void 0);
-__decorate([
-    Type(() => UserAddress),
-    __metadata("design:type", UserAddress)
-], Checkout.prototype, "billingAddress", void 0);
-__decorate([
-    Type(() => ShippingMethod),
-    __metadata("design:type", ShippingMethod)
-], Checkout.prototype, "shipping", void 0);
-__decorate([
-    Type(() => Coupon),
-    __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([
-    Type(() => Payment),
-    __metadata("design:type", Payment)
-], Order.prototype, "payment", void 0);
-
-class CheckoutSubscription extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-__decorate([
-    Type(() => UserAddress),
-    __metadata("design:type", UserAddress)
-], CheckoutSubscription.prototype, "shippingAddress", void 0);
-__decorate([
-    Type(() => UserAddress),
-    __metadata("design:type", UserAddress)
-], CheckoutSubscription.prototype, "billingAddress", void 0);
-__decorate([
-    Type(() => SubscriptionPlan),
-    __metadata("design:type", SubscriptionPlan)
-], CheckoutSubscription.prototype, "subscriptionPlan", void 0);
-__decorate([
-    Type(() => Coupon),
-    __metadata("design:type", Coupon)
-], CheckoutSubscription.prototype, "coupon", void 0);
-
-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;
-    }
-}
-
-var FilterType;
-(function (FilterType) {
-    FilterType["ACCESSORY_IMPORTANCE"] = "accessoryImportance";
-    FilterType["BEARD_PROBLEMS"] = "beardProblems";
-    FilterType["BEARD_SIZE"] = "beardSize";
-    FilterType["BEAUTY_PRODUCT_IMPORTANCE"] = "beautyProductImportance";
-    FilterType["BODY_PROBLEMS"] = "bodyProblems";
-    FilterType["BODY_SHAPE"] = "bodyShape";
-    FilterType["BODY_TATTOOS"] = "bodyTattoos";
-    FilterType["FACE_SKIN_OILINESS"] = "faceSkinOiliness";
-    FilterType["FACE_SKIN_PROBLEMS"] = "faceSkinProblems";
-    FilterType["FACE_SKIN_TONE"] = "faceSkinTone";
-    FilterType["FAMILY_INCOME"] = "familyIncome";
-    FilterType["FRAGRANCE_IMPORTANCE"] = "fragranceImportance";
-    FilterType["HAIR_COLOR"] = "hairColor";
-    FilterType["HAIR_PROBLEMS"] = "hairProblems";
-    FilterType["HAIR_STRANDS"] = "hairStrands";
-    FilterType["HAIR_TYPE"] = "hairType";
-    FilterType["PRODUCT_SPENT"] = "productSpent";
-})(FilterType || (FilterType = {}));
-
-var QuestionsFilters;
-(function (QuestionsFilters) {
-    QuestionsFilters["ACCESSORY_IMPORTANCE"] = "Voc\u00EA gosta de usar acess\u00F3rios masculinos?";
-    QuestionsFilters["BEARD_PROBLEMS"] = "Quais problemas de barba voc\u00EA tem?";
-    QuestionsFilters["BEARD_SIZE"] = "Quais caracteristicas se aplicam \u00E0 sua BARBA/BIGODE?";
-    QuestionsFilters["BEAUTY_PRODUCT_IMPORTANCE"] = "O que descreve melhor a sua rela\u00E7\u00E3o com produtos de beleza e cuidados pessoais?";
-    QuestionsFilters["BODY_PROBLEMS"] = "Qual ou quais preocupa\u00E7\u00F5es voc\u00EA tem com a pele do seu corpo?";
-    QuestionsFilters["BODY_SHAPE"] = "Qual e seu tipo de CORPO?";
-    QuestionsFilters["BODY_TATTOOS"] = "Voc\u00EA tem alguma tatuagem?";
-    QuestionsFilters["FACE_SKIN_OILINESS"] = "Quais caracteristicas se aplicam \u00E0 pele do seu ROSTO?";
-    QuestionsFilters["FACE_SKIN_PROBLEMS"] = "Quais problemas a pele do seu rosto tem?";
-    QuestionsFilters["FACE_SKIN_TONE"] = "Qual seu tom de pele?";
-    QuestionsFilters["FAMILY_INCOME"] = "Qual a sua renda familiar mensal (considerando a renda de todas as pessoas que moram com voc\u00EA)?";
-    QuestionsFilters["FRAGRANCE_IMPORTANCE"] = "O quanto voc\u00EA gosta de experimentar perfumes?";
-    QuestionsFilters["HAIR_COLOR"] = "Seu cabelo \u00E9 naturalmente de qual COR?";
-    QuestionsFilters["HAIR_PROBLEMS"] = "Qual ou quais problemas/caracter\u00EDstica de cabelo te preocupam?";
-    QuestionsFilters["HAIR_STRANDS"] = "Como s\u00E3o seus fios?";
-    QuestionsFilters["HAIR_TYPE"] = "Como \u00E9 o seu cabelo?";
-    QuestionsFilters["PRODUCT_SPENT"] = "Qual \u00E9 o seu nivel de gasto mensal em produtos de beleza e cuidados pessoais?";
-})(QuestionsFilters || (QuestionsFilters = {}));
-
-class BeautyQuestionsHelper {
-    static getAnswers(filter) {
-        switch (filter) {
-            case FilterType.ACCESSORY_IMPORTANCE:
-                return AccessoryImportances;
-            case FilterType.BEARD_PROBLEMS:
-                return BeardProblems;
-            case FilterType.BEARD_SIZE:
-                return BeardSizes;
-            case FilterType.BEAUTY_PRODUCT_IMPORTANCE:
-                return BeautyProductImportances;
-            case FilterType.BODY_PROBLEMS:
-                return BodyProblems;
-            case FilterType.BODY_SHAPE:
-                return BodyShapes;
-            case FilterType.BODY_TATTOOS:
-                return BodyTattoos;
-            case FilterType.FACE_SKIN_OILINESS:
-                return FaceSkinOilinesses;
-            case FilterType.FACE_SKIN_PROBLEMS:
-                return FaceSkinProblems;
-            case FilterType.FACE_SKIN_TONE:
-                return FaceSkinTones;
-            case FilterType.FAMILY_INCOME:
-                return FamilyIncomes;
-            case FilterType.FRAGRANCE_IMPORTANCE:
-                return FragranceImportances;
-            case FilterType.HAIR_COLOR:
-                return HairColors;
-            case FilterType.HAIR_PROBLEMS:
-                return HairProblems;
-            case FilterType.HAIR_STRANDS:
-                return HairStrands;
-            case FilterType.HAIR_TYPE:
-                return HairTypes;
-            case FilterType.PRODUCT_SPENT:
-                return ProductSpents;
-        }
-    }
-    static getQuestions(filter) {
-        const filterKey = Object.keys(FilterType)[Object.values(FilterType).indexOf(filter)];
-        return QuestionsFilters[filterKey];
-    }
-}
-
-class Home extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class ShopMenu extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class ShopSettings extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class InvalidArgumentError extends CustomError {
-    constructor(message) {
-        super(message);
-    }
-}
-
-class RequiredArgumentError extends CustomError {
-    constructor(args) {
-        super(`Required arguments: ${args.join(', ')}`);
-        this.args = args;
-        this.arguments = args;
-    }
-}
-
-class NotFoundError extends CustomError {
-    constructor(message) {
-        super(message);
-    }
-}
-
-class DuplicatedResultsError extends CustomError {
-    constructor(message) {
-        super(message);
-    }
-}
-
-class AxiosAdapter {
-    constructor(config) {
-        this.config = config;
-    }
-    async get(index, id) {
-        try {
-            const { data } = await axios({
-                url: `${this.config.url}/${index}/_doc/${id}`,
-                method: 'GET',
-                responseType: 'json',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `ApiKey ${this.config.credential}`,
-                },
-            });
-            return data._source;
-        }
-        catch (error) {
-            if (!(error instanceof Error))
-                throw error;
-            throw new NotFoundError(error.message);
-        }
-    }
-    async query(index, query) {
-        const { data } = await axios({
-            url: `${this.config.url}/${index}/_search`,
-            method: 'POST',
-            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 {
-            total: data.hits.total.value,
-            hits: data.hits.hits,
-        };
-    }
-    async save(index, data) {
-        await axios({
-            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: `ApiKey ${this.config.credential}` },
-            data,
-        });
-    }
-    async delete(index, id) {
-        await axios({
-            url: `${this.config.url}/${index}/_doc/${id}`,
-            method: 'DELETE',
-            headers: { Authorization: `ApiKey ${this.config.credential}` },
-        });
-    }
-}
-
-class ProductsIndex {
-    constructor(adapter) {
-        this.adapter = adapter;
-        this.index = `products`;
-    }
-    async getById(id) {
-        const data = await this.adapter.get(this.index, id);
-        return Product.toInstance(data);
-    }
-    async search(searchTerm, total, shop) {
-        const size = total || 9;
-        const fields = [
-            'EAN',
-            'brand',
-            'id',
-            'images',
-            'miniatures',
-            'name',
-            'price',
-            'sku',
-            'stock',
-            'slug',
-            'reviews',
-            'hasVariants',
-            'rate',
-        ];
-        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: {
-                    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,
-                        },
-                    },
-                    should: {
-                        match_phrase_prefix: {
-                            'name.search': {
-                                query: `${searchTerm}`,
-                                slop: 10,
-                            },
-                        },
-                    },
-                    filter,
-                },
-            },
-        });
-        search.hits = search.hits
-            .filter((e) => e._source.name !== '')
-            .map((hit) => {
-            RoundProductPricesHelper.roundProductPrices(hit._source);
-            return hit;
-        });
-        return search;
-    }
-    async save(product) {
-        try {
-            const { createdAt, updatedAt, kitProducts, ...data } = product;
-            this.adapter.save(this.index, data);
-        }
-        catch (error) {
-            console.error(error);
-        }
-    }
-    async update(product) {
-        try {
-            await this.adapter.update(this.index, product.id, product);
-        }
-        catch (error) {
-            console.error(error);
-        }
-    }
-    async delete(id) {
-        try {
-            await this.adapter.delete(this.index, id);
-        }
-        catch (error) {
-            console.error(error);
-        }
-    }
-}
-
-const withFirestore = (MixinBase) => {
-    const isObjectsAndNoDate = (data) => data &&
-        !Array.isArray(data) &&
-        typeof data === 'object' &&
-        data?.constructor.name !== 'Timestamp' &&
-        !('seconds' in data);
-    const bindDate = (data, keyName) => {
-        if (data?.constructor.name === 'Timestamp')
-            return data.toDate();
-        if (data && typeof data === 'object' && 'seconds' in data)
-            return new Date(data.seconds * 1000);
-        if (typeof data === 'number' && ['createdAt', 'updatedAt'].includes(keyName))
-            return new Date(data);
-        return data;
-    };
-    const bindAllDateFromObject = (data) => {
-        return Object.keys(data).reduce((object, key) => ({
-            ...object,
-            [key]: isObjectsAndNoDate(data[key])
-                ? bindAllDateFromObject(data[key])
-                : Array.isArray(data[key])
-                    ? data[key].map((element) => (isObjectsAndNoDate(element) ? bindAllDateFromObject(element) : element))
-                    : 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(...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) => {
-                    const plain = data?.toPlain ? data.toPlain() : data;
-                    return omitByRecursivelyInPlace(plain, (value) => value === undefined);
-                },
-                fromFirestore: (snap) => {
-                    const data = snap.data();
-                    let bindedData = null;
-                    try {
-                        const ids = { id: snap.id };
-                        bindedData = bindAllDateFromObject(data);
-                        return this.model.toInstance({ ...bindedData, ...ids });
-                    }
-                    catch (error) {
-                        console.info('id', snap.id);
-                        console.info('data', JSON.stringify(bindedData));
-                        console.error(error);
-                        throw error;
-                    }
-                },
-            };
-        }
-    };
-};
-
-const withHelpers = (MixinBase) => {
-    return class extends MixinBase {
-        toArray(snapShot) {
-            if (Array.isArray(snapShot)) {
-                return snapShot.map((doc) => doc.data());
-            }
-            else {
-                return snapShot.docs.map((doc) => doc.data());
-            }
-        }
-        isSubCollection(repository) {
-            return !isNil(Object.keys(this).find((key) => key === 'parentRepository'));
-        }
-    };
-};
-
-const withGetFirestore = (MixinBase) => {
-    return class GetFirestore extends MixinBase {
-        async get(identifiers) {
-            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 this.interceptors?.response?.(data, intercepted) || data;
-        }
-        buildCollectionPathForGet(identifiers) {
-            return this.isSubCollection(this)
-                ? `${this.parentRepository.collectionName}/${identifiers[this.parentIdField]}/${this.collectionName}`
-                : this.collectionName;
-        }
-    };
-};
-
-var FirestoreFieldType;
-(function (FirestoreFieldType) {
-    FirestoreFieldType["String"] = "string";
-    FirestoreFieldType["Number"] = "number";
-    FirestoreFieldType["Boolean"] = "boolean";
-    FirestoreFieldType["Timestamp"] = "timestamp";
-    FirestoreFieldType["Array"] = "array";
-    FirestoreFieldType["Map"] = "map";
-})(FirestoreFieldType || (FirestoreFieldType = {}));
-
-const withFindFirestore = (MixinBase) => {
-    const checkIfIsFilterOption = (filter) => !isNil(filter?.operator);
-    const getValueFromFilter = (filter) => {
-        return checkIfIsFilterOption(filter) ? filter.value : filter;
-    };
-    const getFinalValueFrom = (value) => isNumber(value) || isString(value) || isDate(value) || Array.isArray(value)
-        ? value
-        : Object.values(getFinalValueFrom);
-    return class FindFirestore extends MixinBase {
-        constructor() {
-            super(...arguments);
-            this.makeFirestoreWhere = (filter) => Object.keys(filter).reduce((queries, fieldName) => [
-                ...queries,
-                ...this.buildWhereSentence(fieldName, is(filter[fieldName])),
-            ], []);
-            this.buildWhereSentence = (fieldName, options) => {
-                if (this.isSubCollection(this) && fieldName === this.parentIdField)
-                    return [];
-                const value = options?.value || options;
-                const object = {};
-                set(object, fieldName, value);
-                const plainInstance = new this.model(object).toPlain();
-                const firestoreFieldName = fieldName.toString().indexOf('.') > -1
-                    ? fieldName.toString()
-                    : Object.keys(plainInstance).find((key) => plainInstance[key]);
-                if (options?.operator === Where.LIKE) {
-                    if (Array.isArray(options?.value) &&
-                        (this.fields[firestoreFieldName] ===
-                            FirestoreFieldType.Array ||
-                            !this.fields[firestoreFieldName]))
-                        return [where(firestoreFieldName, 'array-contains-any', options.value)];
-                    return [where(firestoreFieldName, '>=', options.value), where(firestoreFieldName, '<=', `${options.value}~`)];
-                }
-                if (options?.operator === Where.IN &&
-                    Array.isArray(options?.value) &&
-                    (this.fields[firestoreFieldName] === FirestoreFieldType.Array ||
-                        !this.fields[firestoreFieldName]))
-                    return [where(firestoreFieldName, 'array-contains', options.value)];
-                if (isObject(options) && isNil(options?.operator) && isNil(options?.value)) {
-                    return Object.keys(options).reduce((queries, key) => [
-                        ...queries,
-                        ...this.buildWhereSentence(`${fieldName.toString()}.${key}`, is(options)[key]),
-                    ], []);
-                }
-                return [where(firestoreFieldName, options?.operator || '==', options?.value || options)];
-            };
-            this.makeFirestoreOrderBy = (filters, fieldsToOrderBy) => {
-                const orderByKeys = Object.keys(fieldsToOrderBy || {});
-                if (!orderByKeys.length)
-                    return [];
-                const filtersKeysWithUnordered = Object.keys(filters || {}).filter((filterKey) => !orderByKeys.includes(filterKey));
-                if (filtersKeysWithUnordered.length)
-                    filtersKeysWithUnordered.forEach((filterKey) => (fieldsToOrderBy = {
-                        ...(![Where.EQUALS].includes(is(filters[filterKey]).operator)
-                            ? { [filterKey]: 'asc' }
-                            : {}),
-                        ...fieldsToOrderBy,
-                    }));
-                return Object.keys(fieldsToOrderBy).map((fieldName) => orderBy(fieldName, fieldsToOrderBy[fieldName]));
-            };
-        }
-        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);
-            const queryArgumments = [...queries, ...ordination, ...offsets];
-            const docs = await getDocs(query(collection, ...queryArgumments));
-            const data = docs.docs.map((doc) => doc.data());
-            return {
-                data: (await this.interceptors?.response?.(data, intercepted)) || data,
-                count: enableCount ? this.calculateCount(data, limits) : Infinity,
-            };
-        }
-        buildCollectionPathForFind(filters) {
-            if (!this.isSubCollection(this))
-                return this.collectionName;
-            const parentIdField = this.parentIdField;
-            const parentId = getValueFromFilter(filters?.[parentIdField]);
-            return `${this.parentRepository.collectionName}/${parentId}/${this.collectionName}`;
-        }
-        async defineLimits(filters, limits) {
-            const queries = [];
-            if (limits?.offset) {
-                if (this.model.isModel(limits.offset))
-                    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));
-            }
-            if (limits?.limit)
-                queries.push(limit(limits.limit));
-            return queries;
-        }
-        calculateCount(data, limits) {
-            if (data.length <= 0)
-                return 0;
-            if (data.length < limits?.limit)
-                return data.length;
-            return Infinity;
-        }
-    };
-};
-
-const withCreateFirestore = (MixinBase) => {
-    return class CreateFirestore extends MixinBase {
-        async create(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);
-            const docBuilded = (await this.interceptors?.response?.(doc.data(), intercepted)) || doc.data();
-            return docBuilded;
-        }
-        async save(data) {
-            const id = Object.values(data.identifier)?.shift()?.toString();
-            const collectionPath = this.buildCollectionPathForAdd(data);
-            const collection = this.collection(collectionPath);
-            if (isEmpty(id))
-                return addDoc(collection, data);
-            const docRef = doc(collection, id);
-            await setDoc(docRef, data);
-            return docRef;
-        }
-        buildCollectionPathForAdd(identifiers) {
-            return this.isSubCollection(this)
-                ? `${this.parentRepository.collectionName}/${identifiers[this.parentIdField]}/${this.collectionName}`
-                : this.collectionName;
-        }
-    };
-};
-
-const withUpdateFirestore = (MixinBase) => {
-    const getValueFromParams = (params, field) => (isNil(is(params[field])?.value)
-        ? is(params[field])
-        : is(params[field]).value) || null;
-    const getValueByAction = (options) => {
-        if (isNil(options?.action))
-            return options;
-        if (options?.action === UpdateOptionActions.REMOVE_FIELD)
-            return deleteField();
-        if (options?.action === UpdateOptionActions.NULL)
-            return null;
-        if (Array.isArray(options?.value)) {
-            if (options?.action === UpdateOptionActions.MERGE)
-                return arrayUnion(...options.value);
-            if (options?.action === UpdateOptionActions.REMOVE)
-                return arrayRemove(...options.value);
-        }
-        return options?.value;
-    };
-    return class UpdateFirestore extends MixinBase {
-        async update(data) {
-            const model = new this.model();
-            const keyField = model.identifiersFields.shift();
-            const docRef = doc(this.collection(this.buildCollectionPathForUpdate(data)), getValueFromParams(data, keyField).toString());
-            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)
-                ? `${this.parentRepository.collectionName}/${getValueFromParams(identifiers, this.parentIdField)}/${this.collectionName}`
-                : this.collectionName;
-        }
-        paramsToPlain(params) {
-            const model = this.model;
-            if (model.isModel(params))
-                return params.toPlain();
-            return Object.keys(params).reduce((data, currentKey) => ({
-                ...data,
-                ...((value) => (value === undefined ? {} : { [currentKey]: value }))(getValueByAction(params[currentKey])),
-            }), {});
-        }
-    };
-};
-
-const withDeleteFirestore = (MixinBase) => {
-    return class DeleteFirestore extends MixinBase {
-        async delete(identifiers) {
-            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)
-                ? `${this.parentRepository.collectionName}/${identifiers[this.parentIdField]}/${this.collectionName}`
-                : this.collectionName;
-        }
-    };
-};
-
-const withSubCollection = (MixinBase, ParentModel) => {
-    return class SubCollectionMix extends MixinBase {
-        constructor(...params) {
-            const options = params[0];
-            super(...params);
-            this.parentIdField = options.parentIdField;
-        }
-        collection(path) {
-            return super.collection(path);
-        }
-    };
-};
-
-const withCrudFirestore = (MixinBase) => {
-    return class CrudFirestore extends withUpdateFirestore(withGetFirestore(withFindFirestore(withDeleteFirestore(withCreateFirestore(MixinBase))))) {
-    };
-};
-
-class LeadFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor({ firestore, interceptors }) {
-        super({
-            firestore,
-            collectionName: 'leads',
-            model: Lead,
-            interceptors,
-        });
-    }
-}
-
-class SubscriptionEditionFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), Subscription) {
-    constructor({ firestore, interceptors }, parentRepository) {
-        super({
-            firestore,
-            collectionName: 'editions',
-            parentIdField: 'subscriptionId',
-            model: Edition,
-            interceptors,
-        });
-        this.parentRepository = parentRepository;
-    }
-}
-
-class SubscriptionFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor({ firestore, interceptors, }) {
-        super({
-            firestore,
-            collectionName: 'subscription',
-            model: Subscription,
-            interceptors,
-        });
-    }
-}
-
-class SubscriptionPaymentFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), Subscription) {
-    constructor({ firestore, interceptors }, parentRepository) {
-        super({
-            firestore,
-            collectionName: 'payments',
-            parentIdField: 'subscriptionId',
-            model: SubscriptionPayment,
-            interceptors,
-        });
-        this.parentRepository = parentRepository;
-    }
-}
-
-class UserAddressFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), User) {
-    constructor({ firestore, interceptors }, parentRepository) {
-        super({
-            firestore,
-            collectionName: 'address',
-            parentIdField: 'userId',
-            model: UserAddress,
-            interceptors,
-        });
-        this.parentRepository = parentRepository;
-    }
-}
-
-class UserBeautyProfileFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), User) {
-    constructor({ firestore, interceptors }, parentRepository) {
-        super({
-            firestore,
-            collectionName: 'CX',
-            parentIdField: 'userId',
-            model: BeautyProfile,
-            interceptors,
-        });
-        this.parentRepository = parentRepository;
-    }
-}
-
-class UserFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor({ firestore, interceptors }) {
-        super({
-            firestore,
-            collectionName: 'users',
-            model: User,
-            interceptors,
-        });
-    }
-    async get(identifiers) {
-        const user = await super.get({ id: identifiers.id });
-        user.beautyProfile = await this.getBeautyProfile(user.id);
-        user.isSubscriber = await this.checkIfIsSubscriber(user.id);
-        return user;
-    }
-    async checkIfExistsByField(field, value) {
-        const result = await this.find({ filters: { [field]: value } });
-        return result.count > 0;
-    }
-    buildModelInstance() {
-        const { fromFirestore, toFirestore } = super.buildModelInstance();
-        return {
-            toFirestore: (data) => {
-                const plain = toFirestore(data);
-                delete plain.isSubscriber;
-                return plain;
-            },
-            fromFirestore,
-        };
-    }
-    async getBeautyProfile(userId) {
-        const beautyProfile = await getDoc(doc(this.collection(`${this.collectionName}/${userId}/CX`).withConverter(this.buildBeautyProfileModelInstance()), 'beautyProfile'));
-        return beautyProfile.data();
-    }
-    async checkIfIsSubscriber(userId) {
-        const docs = await getDocs(query(this.collection('subscription'), where('user.id', '==', userId), where('status', '==', 'active')));
-        return !!docs && !!docs.size;
-    }
-    buildBeautyProfileModelInstance() {
-        return {
-            toFirestore: (data) => data.toPlain(),
-            fromFirestore: (snap) => BeautyProfile.toInstance(snap.data()),
-        };
-    }
-}
-
-class UserPaymentMethodFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), User) {
-    constructor({ firestore, interceptors }, parentRepository) {
-        super({
-            firestore,
-            collectionName: 'payment_method',
-            parentIdField: 'userId',
-            model: UserPaymentMethod,
-            interceptors,
-        });
-        this.parentRepository = parentRepository;
-    }
-}
-
-class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    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)));
-        if (categoryDocs.size > 1)
-            throw new DuplicatedResultsError('Query returned duplicated values');
-        if (categoryDocs.empty)
-            throw new NotFoundError(`Document with slug ${slug} not found`);
-        return categoryDocs.docs[0].data();
-    }
-    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, gender }),
-        })));
-        return homeSections;
-    }
-    async mountCategory(category, options) {
-        if (!category.products)
-            throw new RequiredArgumentError(['Category products is empty']);
-        const chunks = chunk(category.products, 10);
-        const products = [];
-        const wheres = [];
-        for (const productIds of chunks) {
-            if (options?.limit && products.length >= options?.limit)
-                break;
-            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));
-            if (productSnap.empty)
-                continue;
-            products.push(...productSnap.docs);
-        }
-        return is(products);
-    }
-    getCategoryByShop(shop) {
-        return;
-    }
-    getChildren(parentId) {
-        return;
-    }
-    isChild(id, parentId) {
-        return;
-    }
-}
-
-class ProductFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor({ firestore, interceptors }) {
-        super({
-            firestore,
-            collectionName: 'productsErpVitrine',
-            model: Product,
-            interceptors,
-        });
-        this.reviews = {};
-    }
-    async getBySlug(slug) {
-        const result = await this.find({
-            filters: {
-                slug: { operator: Where.EQUALS, value: slug },
-            },
-        });
-        return result?.data?.shift();
-    }
-    async fetchReviews(status) {
-        const { data: products } = await this.find();
-        products.forEach((product) => {
-            if ([undefined, 0].includes(product.reviews?.length))
-                return;
-            const productInfo = {
-                productId: product.id,
-                productName: product.name,
-                productSku: product.sku,
-            };
-            this.reviews.pending = [];
-            this.reviews.approved = [];
-            this.reviews.rejected = [];
-            product.reviews.forEach((review) => {
-                if ([null, undefined].includes(review.status))
-                    return this.reviews.pending.push({ ...review, ...productInfo });
-                if (review.status === false)
-                    return this.reviews.rejected.push({ ...review, ...productInfo });
-                if (!!review.status)
-                    return this.reviews.approved.push({ ...review, ...productInfo });
-                return review;
-            });
-        });
-        return this.reviews[status];
-    }
-    cleanShoppingCountFromIds() {
-        return;
-    }
-    findCatalog(params) {
-        return this.find(params);
-    }
-}
-
-class ProductVariantFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), Product) {
-    constructor({ firestore, interceptors }, parentRepository) {
-        super({
-            firestore,
-            collectionName: 'variants',
-            parentIdField: 'productId',
-            model: Variant,
-            interceptors,
-        });
-        this.parentRepository = parentRepository;
-    }
-}
-
-class SubscriptionProductFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    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, 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, interceptors }) {
-        super({
-            firestore,
-            collectionName: 'coupons',
-            model: Coupon,
-            interceptors,
-        });
-    }
-    buildModelInstance() {
-        const { fromFirestore, toFirestore } = super.buildModelInstance();
-        return {
-            toFirestore: (data) => {
-                const plain = toFirestore(data);
-                if (!!data.expiresIn)
-                    plain.expiresIn = data.expiresIn.getTime();
-                return plain;
-            },
-            fromFirestore: (snap) => {
-                const instance = fromFirestore(snap);
-                if (!isNil(instance.expiresIn))
-                    instance.expiresIn = new Date(snap.data().expiresIn);
-                return instance;
-            },
-        };
-    }
-}
-
-class OrderFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    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) => {
-                    const prices = !!lineItem.price;
-                    const shopPrice = prices[order.shop];
-                    if (!!shopPrice)
-                        lineItem.price = shopPrice;
-                    return lineItem;
-                });
-            }
-            return order;
-        };
-    }
-    buildModelInstance() {
-        const { fromFirestore, toFirestore } = super.buildModelInstance();
-        return {
-            toFirestore: (data) => toFirestore(data?.toPlain ? data.toPlain() : data),
-            fromFirestore: (snap) => {
-                const instance = fromFirestore(snap);
-                return this.orderFromFirestore(instance);
-            },
-        };
-    }
-}
-
-class LegacyOrderFirestoreRepository extends OrderFirestoreRepository {
-    constructor({ firestore, interceptors }) {
-        super({
-            firestore,
-            interceptors,
-        });
-        this.collectionName = 'legacyOrders';
-    }
-}
-
-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, interceptors, }) {
-        super({
-            firestore,
-            collectionName: 'subscriptionPlans',
-            model: SubscriptionPlan,
-            interceptors,
-        });
-    }
-}
-
-class HomeFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor({ firestore, interceptors }) {
-        super({
-            firestore,
-            collectionName: 'dms',
-            model: Home,
-            interceptors,
-        });
-        this.homeCategoryGroupToPlain = (homeCategoryGroup) => ({
-            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)),
-        });
-    }
-    buildModelInstance() {
-        const { fromFirestore, toFirestore } = super.buildModelInstance();
-        return {
-            toFirestore: (data) => {
-                const modifiedData = this.homeToFirestore(data);
-                return toFirestore(modifiedData);
-            },
-            fromFirestore: (snap) => {
-                const instance = fromFirestore(snap);
-                return this.homeFromFirestore(instance);
-            },
-        };
-    }
-    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, 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,
-        });
-    }
-}
-
-class AuthenticationFirebaseAuthService {
-    constructor(firebaseAuth) {
-        this.firebaseAuth = firebaseAuth;
-    }
-    async signInWithEmailAndPassword(data) {
-        const credentials = await signInWithEmailAndPassword(this.firebaseAuth, data.email, data.password);
-        const user = credentials.user;
-        return {
-            id: user.uid,
-            displayName: user.displayName,
-            email: user.email,
-            phone: user.phoneNumber,
-            isAnonymous: false,
-        };
-    }
-    async signInWithGoogle() {
-        const credentials = await signInWithPopup(this.firebaseAuth, new GoogleAuthProvider());
-        const user = credentials.user;
-        return {
-            id: user.uid,
-            displayName: user.displayName,
-            email: user.email,
-            phone: user.phoneNumber,
-            isAnonymous: false,
-        };
-    }
-    async signOut() {
-        this.firebaseAuth.signOut();
-    }
-    async signInAnonymously() {
-        const auth = await signInAnonymously(this.firebaseAuth);
-        const user = auth.user;
-        user.id = auth.user.uid;
-        return user;
-    }
-    async sendPasswordResetEmail(email) {
-        return sendPasswordResetEmail(this.firebaseAuth, email);
-    }
-}
-
-class RegisterFirebaseAuthService {
-    constructor(firebaseAuth) {
-        this.firebaseAuth = firebaseAuth;
-    }
-    async register(params) {
-        if (!params.email)
-            throw new RequiredArgumentError(['email']);
-        try {
-            const auth = await createUserWithEmailAndPassword(this.firebaseAuth, params.email, params.password);
-            const user = is(auth.user);
-            if (!user)
-                throw new Error('User not created');
-            await sendEmailVerification(user);
-            user.id = user.uid;
-            return user;
-        }
-        catch (error) {
-            if (!(error instanceof Error))
-                throw error;
-            const firebaseError = error;
-            if (firebaseError.code === 'auth/email-already-in-use')
-                throw new UserAlreadyRegisteredError('Email already registered');
-            if (firebaseError.code === 'auth/weak-password')
-                throw new WeakPasswordError();
-            throw error;
-        }
-    }
-}
-
-class AttributeOptionHelper {
-}
-AttributeOptionHelper.FindByAttribute = (attributeName, fields) => {
-    if (fields.includes(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))
-        return { columnName: attributeName.toString(), attributeName };
-    if (Array.isArray(fieldOption))
-        return { columnName: attributeName.toString(), attributeName, fields: fieldOption };
-    return { attributeName, columnName: attributeName.toString(), ...fieldOption };
-};
-AttributeOptionHelper.CheckIsColumnOption = (fieldValue) => !!fieldValue?.columnName;
-AttributeOptionHelper.FindColumnOptionFromList = (columnName, fields) => {
-    if (fields.includes(columnName))
-        return { columnName, attributeName: columnName };
-    const field = is(fields.find((field) => {
-        if (!isObject(field))
-            return false;
-        const columnOption = Object.values(field).find((option) => AttributeOptionHelper.CheckIsColumnOption(option) && option.columnName === columnName ? option : {});
-        return AttributeOptionHelper.CheckIsColumnOption(columnOption) && columnOption?.columnName === columnName;
-    }) || {});
-    const attributeName = Object.keys(field).find((fieldOptionFromList) => AttributeOptionHelper.CheckIsColumnOption(field[fieldOptionFromList]) || Array.isArray(field[fieldOptionFromList]));
-    const fieldOption = field?.[attributeName];
-    if (Array.isArray(fieldOption))
-        return { attributeName: attributeName, fields: fieldOption };
-    return {
-        attributeName: attributeName || columnName,
-        columnName,
-        ...fieldOption,
-    };
-};
-
-var HasuraGraphQLWhere;
-(function (HasuraGraphQLWhere) {
-    HasuraGraphQLWhere["EQUALS"] = "_eq";
-    HasuraGraphQLWhere["GT"] = "_gt";
-    HasuraGraphQLWhere["GTE"] = "_gte";
-    HasuraGraphQLWhere["IN"] = "_in";
-    HasuraGraphQLWhere["NOTIN"] = "_nin";
-    HasuraGraphQLWhere["LT"] = "_lt";
-    HasuraGraphQLWhere["LTE"] = "_lte";
-    HasuraGraphQLWhere["LIKE"] = "_like";
-    HasuraGraphQLWhere["NOTLIKE"] = "_nlike";
-    HasuraGraphQLWhere["ISNULL"] = "_is_null";
-    HasuraGraphQLWhere["ISNOTNULL"] = "_is_null";
-    HasuraGraphQLWhere["JSON_CONTAINS"] = "_contains";
-    HasuraGraphQLWhere["JSON_HAS_KEYS_ANY"] = "_has_keys_any";
-})(HasuraGraphQLWhere || (HasuraGraphQLWhere = {}));
-
-var HasuraGraphQLColumnType;
-(function (HasuraGraphQLColumnType) {
-    HasuraGraphQLColumnType["Int"] = "Int";
-    HasuraGraphQLColumnType["Float"] = "Float";
-    HasuraGraphQLColumnType["Boolean"] = "Boolean";
-    HasuraGraphQLColumnType["String"] = "String";
-    HasuraGraphQLColumnType["DateTime"] = "timestampz";
-    HasuraGraphQLColumnType["Json"] = "json";
-    HasuraGraphQLColumnType["Jsonb"] = "jsonb";
-    HasuraGraphQLColumnType["Enum"] = "enum";
-    HasuraGraphQLColumnType["Uuid"] = "uuid";
-})(HasuraGraphQLColumnType || (HasuraGraphQLColumnType = {}));
-
-class FilterOptionHelper {
-}
-FilterOptionHelper.CheckIfIsFilterOption = (filter) => !isNil(filter?.operator);
-FilterOptionHelper.GetValueFromFilter = (filter, fieldOption) => {
-    if (!FilterOptionHelper.CheckIfIsFilterOption(filter))
-        return filter;
-    if (filter.operator === Where.ISNULL)
-        return true;
-    if (filter.operator === Where.ISNOTNULL)
-        return false;
-    const converter = fieldOption.to
-        ? fieldOption.to
-        : (value) => filter.operator === Where.LIKE && !Array.isArray(filter.value) && value.indexOf('%') < 0
-            ? `%${value}%`
-            : value;
-    return Array.isArray(filter.value) && !fieldOption.fields && [Where.IN, Where.NOTIN].includes(filter.operator)
-        ? filter.value.map((fieldValue) => converter(fieldValue))
-        : converter(filter.value);
-};
-
-class BindFilterQueryHelper {
-}
-BindFilterQueryHelper.MakeGraphQLWhere = (filter, fields) => Object.keys(filter).reduce((variables, fieldName) => {
-    const columnOption = AttributeOptionHelper.FindByAttribute(fieldName, fields);
-    if (!columnOption.bindFindFilter)
-        return {
-            ...variables,
-            ...{
-                [columnOption.columnName]: BindFilterQueryHelper.BuildWhereSentence(fieldName, filter[fieldName], fields),
-            },
-        };
-    const builtFilter = columnOption.bindFindFilter(filter[fieldName]);
-    return {
-        ...variables,
-        ...Object.keys(builtFilter).reduce((variablesList, columnName) => ({
-            ...variablesList,
-            [columnName]: BindFilterQueryHelper.BuildWhereSentence(fieldName, builtFilter[columnName], fields),
-        }), {}),
-    };
-}, {});
-BindFilterQueryHelper.BuildWhereSentence = (field, options, fields) => {
-    const fieldSentenceOptions = AttributeOptionHelper.FindByAttribute(field, fields);
-    const isNestedField = !Array.isArray(options) &&
-        isObject(options) &&
-        isNil(options?.operator) &&
-        isNil(options?.value) &&
-        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]), fieldSentenceOptions?.fields || columnFields || fields),
-            };
-        }, {});
-    if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))
-        return {
-            [fieldSentenceOptions.fields[0]]: BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions),
-        };
-    if (!Array.isArray(options) && isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
-        options = Object.values(options)[0];
-    return Array.isArray(options)
-        ? options.reduce((whereSentence, option) => ({
-            ...whereSentence,
-            ...BindFilterQueryHelper.BuildOperatorSentence(option, fieldSentenceOptions),
-        }), {})
-        : BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions);
-};
-BindFilterQueryHelper.BuildOperatorSentence = (options, fieldOption) => ({
-    [BindFilterQueryHelper.GetHasuraOperator(options, fieldOption)]: FilterOptionHelper.GetValueFromFilter(options, fieldOption),
-});
-BindFilterQueryHelper.GetHasuraOperator = (options, fieldOption) => FilterOptionHelper.CheckIfIsFilterOption(options)
-    ? fieldOption.type === HasuraGraphQLColumnType.Jsonb
-        ? BindFilterQueryHelper.GetHasuraJsonbOperator(options)
-        : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find((graphQLOperator) => graphQLOperator ===
-            Object.keys(Where).find((operator) => Where[operator] === options?.operator))]
-    : HasuraGraphQLWhere.EQUALS;
-BindFilterQueryHelper.GetHasuraJsonbOperator = (options) => options.operator === Where.IN
-    ? HasuraGraphQLWhere.JSON_CONTAINS
-    : options.operator === Where.LIKE
-        ? HasuraGraphQLWhere.JSON_HAS_KEYS_ANY
-        : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find((graphQLOperator) => graphQLOperator ===
-            Object.keys(Where).find((operator) => Where[operator] === options?.operator))];
-
-class GraphQLFieldHelper {
-}
-GraphQLFieldHelper.CheckIsGraphQLParams = (params) => !isString(params) && Array.isArray(params) && params.length >= 0 && !!params[0].operation;
-GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields = (fields) => {
-    return fields
-        ?.map((field) => {
-        if (isString(field))
-            return field.toString();
-        if (field === 'affected_rows')
-            return field;
-        const fieldName = Object.keys(field).shift();
-        const fieldValue = is(field[fieldName]);
-        if (Array.isArray(fieldValue))
-            return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) };
-        if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue))
-            return;
-        const isNestedField = !!fieldValue.fields;
-        if (isNestedField)
-            return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue);
-        return fieldValue.columnName;
-    })
-        .filter((field) => !!field);
-};
-GraphQLFieldHelper.ConvertFieldValueFrom = (data, fields) => Object.keys(data).reduce((result, columnName) => {
-    const { attributeName, fields: attributeFields, from, } = AttributeOptionHelper.FindColumnOptionFromList(columnName, fields);
-    if (!!attributeFields && Array.isArray(attributeFields)) {
-        if (Array.isArray(data[columnName]))
-            return {
-                ...result,
-                [attributeName]: from
-                    ? from(data[columnName], data)
-                    : is(data[columnName]).map((value) => GraphQLFieldHelper.ConvertFieldValueFrom(is(value), attributeFields)),
-            };
-        if (isObject(data[columnName]))
-            return {
-                ...result,
-                [attributeName]: !!from
-                    ? from(data[columnName])
-                    : GraphQLFieldHelper.ConvertFieldValueFrom(is(data[columnName]), attributeFields),
-            };
-    }
-    if (!!from)
-        return { ...result, [attributeName]: from(data[columnName], data) };
-    return {
-        ...result,
-        [attributeName]: isString(data[columnName]) ? parseDateTime(data[columnName].toString()) : data[columnName],
-    };
-}, {});
-GraphQLFieldHelper.ConvertFieldValueTo = (instance, fields, update = false) => {
-    const data = instance.toPlain?.() || instance;
-    return Object.keys(data).reduce((result, attributeName) => {
-        const { columnName, fields: attributeFields, foreignKeyColumn, to, bindPersistData, } = AttributeOptionHelper.FindByAttribute(attributeName, fields);
-        if (bindPersistData)
-            return {
-                ...result,
-                ...bindPersistData(data[attributeName], instance),
-            };
-        if (isNil(columnName))
-            return result;
-        if (!!foreignKeyColumn &&
-            !isEmpty(foreignKeyColumn) &&
-            !Object.keys(foreignKeyColumn).filter((key) => !is(data[attributeName])?.[key]).length)
-            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) &&
-            !isDate(data[attributeName]))
-            return result;
-        if (!!columnName &&
-            Array.isArray(attributeFields) &&
-            isObject(data[attributeName])) {
-            const converted = !isNil(columnName) && to
-                ? to(instance[attributeName], instance)
-                : data[attributeName];
-            return {
-                ...result,
-                ...(converted !== undefined
-                    ? {
-                        [columnName]: {
-                            data: instance[attributeName] instanceof BaseModel
-                                ? GraphQLFieldHelper.ConvertFieldValueTo(data[attributeName], attributeFields)
-                                : converted,
-                        },
-                    }
-                    : {}),
-            };
-        }
-        if (!!to)
-            return {
-                ...result,
-                [columnName]: to(instance[attributeName], instance),
-            };
-        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 {
-        constructor(...params) {
-            const options = params?.[0];
-            super(...params);
-            this.insertGraphQLOperation = options?.insertGraphQLOperation || `insert_${this.tableName}_one`;
-            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);
-        }
-        async save(data) {
-            const primaryKeyColumns = this.model.identifiersFields.map((field) => AttributeOptionHelper.FindByAttribute(field, this.fields).columnName);
-            const foreignKeyColumns = this.fields
-                .map((field) => {
-                const columnOptions = Object.values(field).shift();
-                return (AttributeOptionHelper.CheckIsColumnOption(columnOptions) &&
-                    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),
-                    },
-                ]);
-            })
-                .filter(Boolean)
-                .reduce((keys, current) => [...keys, ...current], []);
-            const result = await this.mutation(this.insertGraphQLOperation, [...primaryKeyColumns, ...foreignKeyColumns], {
-                object: { type: this.insertGraphQLObjectType, required: true, value: this.convertDataToHasura(data) },
-            });
-            return { ...data.toPlain(), ...this.convertDataFromHasura(result[this.insertGraphQLOperation]).toPlain() };
-        }
-    };
-};
-
-const withDeleteHasuraGraphQL = (MixinBase) => {
-    return class DeleteHasuraGraphQLMixin extends MixinBase {
-        constructor(...params) {
-            const options = params?.[0];
-            super(...params);
-            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) => {
-                const identifierBinded = identifier;
-                if (isNil(instance.identifier[identifierBinded]))
-                    return ids;
-                const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields);
-                const value = columnOption.to(identifiers[identifier], instance);
-                return {
-                    ...ids,
-                    [columnOption.columnName]: {
-                        type: this.getAttributeGraphQLTypeOf(columnOption.type || value),
-                        value,
-                        required: true,
-                    },
-                };
-            }, {}));
-        }
-    };
-};
-
-const withHasuraGraphQL = (MixinBase) => {
-    return class HasuraGraphQLMixin extends MixinBase {
-        constructor(...params) {
-            const options = params[0];
-            super(...params);
-            this.tableName = options.tableName;
-            this.endpoint = options.endpoint;
-            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)
-                    ? {}
-                    : {
-                        'X-Hasura-Role': this.authOptions.authRole.role,
-                        'X-Hasura-User-Id': this.authOptions?.authRole?.userId,
-                    }),
-            };
-        }
-        async mutation(operation, fields, variables) {
-            const resultQuery = mutation({
-                operation,
-                variables,
-                fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fields),
-            });
-            return this.fetch(resultQuery);
-        }
-        async query(operation, fields, variables) {
-            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 { data: result } = await axios({
-                url: `${this.endpoint}`,
-                method: 'POST',
-                data: params,
-                headers,
-            });
-            if (!isNil(result.errors))
-                throw new Error(JSON.stringify(result.errors));
-            this.logger.with('returns').log(result);
-            return result.data;
-        }
-        getAttributeGraphQLTypeOf(value) {
-            if (isUUID(value))
-                return 'uuid';
-            if (isString(value))
-                return 'String';
-            if (isBoolean(value))
-                return 'Boolean';
-            if (value instanceof Date)
-                return 'timestamptz';
-            if (isInteger(value))
-                return 'Int';
-            if (isNumber(value))
-                return 'numeric';
-            throw new Error('Type not implemented yet');
-        }
-        checkIfIsDateTimeAndParse(value) {
-            if (!/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.test(value))
-                return value;
-            const date = parseISO(value);
-            if (isNaN$1(date.getTime()))
-                return value;
-            return date;
-        }
-        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),
-                };
-        }
-    };
-};
-
-const withUpdateHasuraGraphQL = (MixinBase) => {
-    const getValueByAction = (options) => {
-        if (options instanceof BaseModel)
-            return options.toPlain();
-        if (isNil(options?.action))
-            return options;
-        if ([UpdateOptionActions.REMOVE_FIELD.toString(), UpdateOptionActions.NULL.toString()].includes(options.action))
-            return null;
-        return options.value;
-    };
-    return class UpdateHasuraGraphQLMixin extends MixinBase {
-        constructor(...params) {
-            const options = params?.[0];
-            super(...params);
-            this.updateGraphQLOperation = options?.updateGraphQLOperation || `update_${this.tableName}_by_pk`;
-            this.updateGraphQLObjectType = options?.updateGraphQLObjectType || `${this.tableName}_set_input`;
-            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: {
-                    type: this.updateGraphQLObjectType,
-                    value: this.convertDataToHasura(this.model.toInstance(plainData), true),
-                    required: true,
-                },
-                pk_columns: { type: this.updateGraphQLPKType, value: this.getUpdateModelKeys(plainData), required: true },
-            });
-            return this.model.toInstance(plainData);
-        }
-        paramsToPlain(params) {
-            const model = this.model;
-            if (model.isModel(params))
-                return params.toPlain();
-            return Object.keys(params).reduce((data, currentKey) => ({
-                ...data,
-                ...(params[currentKey] !== undefined && {
-                    [currentKey]: getValueByAction(is(params[currentKey])),
-                }),
-            }), {});
-        }
-        getUpdateModelKeys(data) {
-            const instance = this.model.toInstance(data);
-            return this.model.identifiersFields.reduce((ids, identifier) => {
-                const identifierBinded = identifier;
-                if (isNil(instance.identifier[identifierBinded]))
-                    return ids;
-                const columnOption = AttributeOptionHelper.FindByAttribute(identifierBinded, this.fields);
-                const value = columnOption?.to?.(data[identifierBinded], instance) || data[columnOption.attributeName];
-                return {
-                    ...ids,
-                    [columnOption.columnName]: value,
-                };
-            }, {});
-        }
-    };
-};
-
-const withGetHasuraGraphQL = (MixinBase) => {
-    return class GetHasuraGraphQLMixin extends MixinBase {
-        constructor(...params) {
-            const options = params?.[0];
-            super(...params);
-            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) => {
-                const identifierBinded = identifier;
-                if (isNil(instance[identifierBinded]))
-                    return ids;
-                const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields);
-                const value = columnOption?.to?.(identifiers[identifier], instance) ||
-                    identifiers[identifier];
-                return {
-                    ...ids,
-                    [columnOption.columnName]: {
-                        type: this.getAttributeGraphQLTypeOf(columnOption.type || value),
-                        value,
-                        required: true,
-                    },
-                };
-            }, {}));
-            const data = result[this.getGraphQLOperation];
-            if (isNil(data))
-                throw new NotFoundError(`${instance.constructor.name} not found`);
-            return this.convertDataFromHasura(result[this.getGraphQLOperation]);
-        }
-    };
-};
-
-const withFindHasuraGraphQL = (MixinBase) => {
-    return class FindHasuraGraphQLMixin extends MixinBase {
-        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: 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: 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,
-                },
-                ...(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));
-            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]),
-                        };
-                    }, {}),
-                }),
-            };
-        }
-    };
-};
-
-const withCrudHasuraGraphQL = (MixinBase) => {
-    return class CrudHasuraGraphQLMixin extends withUpdateHasuraGraphQL(withGetHasuraGraphQL(withFindHasuraGraphQL(withDeleteHasuraGraphQL(withCreateHasuraGraphQL(MixinBase))))) {
-    };
-};
-
-class CategoryHasuraGraphQL extends Category {
-}
-
-class ProductHasuraGraphQL extends Product {
-}
-__decorate([
-    Type(() => KitProductHasuraGraphQL),
-    __metadata("design:type", Array)
-], ProductHasuraGraphQL.prototype, "kitProducts", void 0);
-
-class KitProductHasuraGraphQL extends KitProduct {
-}
-__decorate([
-    Type(() => ProductHasuraGraphQL),
-    __metadata("design:type", ProductHasuraGraphQL)
-], KitProductHasuraGraphQL.prototype, "kit", void 0);
-__decorate([
-    Type(() => ProductHasuraGraphQL),
-    __metadata("design:type", ProductHasuraGraphQL)
-], KitProductHasuraGraphQL.prototype, "product", void 0);
-
-class VariantHasuraGraphQL extends Variant {
-    constructor() {
-        super(...arguments);
-        this.name = '';
-        this.hasVariants = false;
-    }
-}
-
-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, 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' } },
-                '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'],
-                    },
-                },
-            ],
-        });
-        this.productRepository = productRepository;
-        this.categoryFilterRepository = categoryFilterRepository;
-    }
-    async create(params) {
-        const { metadata, ...data } = params;
-        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 }, options: { enableCount: false } })).data?.[0]
-            : super.get(identifiers);
-    }
-    async update(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, 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 } = 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 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));
-        const categoriesHasura = categoryIds.filter((categoryId) => +categoryId > 0);
-        const categories = [];
-        if (categoriesFirestore.length)
-            categories.push(...(await this.find({
-                filters: { firestoreId: { operator: Where.IN, value: categoriesFirestore.filter(Boolean) }, published: true },
-            }).then(({ data }) => data)));
-        if (categoriesHasura.length)
-            categories.push(...(await this.find({
-                filters: { id: { operator: Where.IN, value: categoriesHasura.filter(Boolean) }, published: true },
-            }).then(({ data }) => data)));
-        if (!categories.length)
-            return [];
-        const homeSections = await Promise.all(categories.map(async (category) => ({
-            category,
-            products: await this.mountCategory(category, { limit, hasStock: true, gender }),
-        })));
-        return homeSections;
-    }
-    async mountCategory(category, options) {
-        if (!category?.products?.length)
-            return [];
-        const products = [];
-        const { data: productsData } = await this.productRepository.find({
-            filters: {
-                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',
-                'name',
-                'slug',
-                'images',
-                'miniatures',
-                'price',
-                'fullPrice',
-                'subscriberDiscountPercentage',
-                'subscriberPrice',
-                'stock',
-                'published',
-                'CEST',
-                'EAN',
-                'NCM',
-                'brand',
-                'costPrice',
-                'hasVariants',
-                'isKit',
-                'sku',
-                'rate',
-                'tags',
-                'type',
-                'shoppingCount',
-                'gender',
-                'createdAt',
-            ],
-            ...(options?.limit ? { limits: { limit: options?.limit } } : {}),
-            options: { enableCount: false },
-        });
-        products.push(...productsData);
-        return products;
-    }
-    async getId(id) {
-        if (!Number.isNaN(+id))
-            return 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`);
-    }
-    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 } },
-                },
-            });
-            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.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 null;
-        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;
-    }
-    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, interceptors, }) {
-        super({
-            tableName: 'product',
-            model: ProductHasuraGraphQL,
-            endpoint,
-            authOptions,
-            interceptors,
-            fields: [],
-        });
-        this.bindReviewToModel = (plain) => ({
-            ...is(omit(plain, ['product_id', 'created_at', 'updated_at', 'person_id', 'order_id'])),
-            createdAt: typeof plain.created_at === 'string' ? new Date(plain.created_at) : plain.created_at,
-            updatedAt: typeof plain.updated_at === 'string' ? new Date(plain.updated_at) : plain.updated_at,
-            personId: plain.person_id,
-            orderId: plain.order_id,
-        });
-        this.bindReviewToHasura = (review) => ({
-            ...is(omit(review, ['productId', 'createdAt', 'updatedAt', 'personId', 'orderId'])),
-            person_id: review.personId,
-            order_id: review.orderId,
-        });
-        const commonFields = [
-            { id: { columnName: 'id', to: (value) => +value, from: (value) => value.toString() } },
-            { firestoreId: { columnName: 'firestore_id' } },
-            { productId: { columnName: 'main_product_id' } },
-            { CEST: { columnName: 'cest' } },
-            { EAN: { columnName: 'ean' } },
-            { NCM: { columnName: 'ncm' } },
-            'brand',
-            { costPrice: { columnName: 'cost_price' } },
-            {
-                description: {
-                    columnName: 'description',
-                    from: (description, data) => ({
-                        description,
-                        differentials: data.differentials,
-                        whoMustUse: data.who_must_use,
-                        howToUse: data.how_to_use,
-                        brand: data.brand_description,
-                        ingredients: data.ingredients,
-                    }),
-                    bindFindFilter: (filters) => {
-                        return {
-                            ...(filters?.description && { description: filters.description }),
-                            ...(filters.differentials && { differentials: filters.differentials }),
-                            ...(filters.whoMustUse && {
-                                who_must_use: filters.whoMustUse,
-                            }),
-                            ...(filters.howToUse && {
-                                how_to_use: filters.howToUse,
-                            }),
-                            ...(filters.brand && {
-                                brand_description: filters.brand,
-                            }),
-                            ...(filters.ingredients && {
-                                ingredients: filters.ingredients,
-                            }),
-                        };
-                    },
-                    bindPersistData: (descriptionData) => ({
-                        ...(descriptionData?.description && { description: descriptionData.description }),
-                        ...(descriptionData.differentials && { differentials: descriptionData.differentials }),
-                        ...(descriptionData.whoMustUse && {
-                            who_must_use: descriptionData.whoMustUse,
-                        }),
-                        ...(descriptionData.howToUse && { how_to_use: descriptionData.howToUse }),
-                        ...(descriptionData.brand && { brand_description: descriptionData.brand }),
-                        ...(descriptionData.ingredients && { ingredients: descriptionData.ingredients }),
-                    }),
-                },
-            },
-            { differentials: { columnName: 'differentials' } },
-            { whoMustUse: { columnName: 'who_must_use' } },
-            { howToUse: { columnName: 'how_to_use' } },
-            { brandDescription: { columnName: 'brand_description' } },
-            { ingredients: { columnName: 'ingredients' } },
-            { hasVariants: { columnName: 'has_variants' } },
-            {
-                images: {
-                    columnName: 'images',
-                    to: (value) => (value?.length > 0 ? `{"${value?.join?.(`","`) || ''}"}` : `{}`),
-                },
-            },
-            {
-                miniatures: {
-                    columnName: 'miniatures',
-                    to: (value) => (value?.length > 0 ? `{"${value?.join?.(`","`) || ''}"}` : `{}`),
-                },
-            },
-            'name',
-            {
-                price: {
-                    columnName: 'price',
-                    from: (price, data) => ({
-                        price,
-                        fullPrice: data.full_price,
-                        subscriberDiscountPercentage: data.subscriber_discount_percentage,
-                        subscriberPrice: data.subscriber_price,
-                    }),
-                    bindFindFilter: (filters) => {
-                        return {
-                            ...((filters?.price || filters?.price === 0) && { price: filters.price }),
-                            ...((filters.fullPrice || filters.fullPrice === 0) && { full_price: filters.fullPrice }),
-                            ...((filters.subscriberDiscountPercentage || filters.subscriberDiscountPercentage === 0) && {
-                                subscriber_discount_percentage: filters.subscriberDiscountPercentage,
-                            }),
-                            ...((filters.subscriberPrice || filters.subscriberPrice === 0) && {
-                                subscriber_price: filters.subscriberPrice,
-                            }),
-                        };
-                    },
-                    bindPersistData: (priceData) => ({
-                        ...(priceData?.price >= 0 && { price: priceData.price }),
-                        ...(priceData.fullPrice >= 0 && { full_price: priceData.fullPrice }),
-                        ...(priceData.subscriberDiscountPercentage >= 0 && {
-                            subscriber_discount_percentage: priceData.subscriberDiscountPercentage,
-                        }),
-                        ...(priceData.subscriberPrice >= 0 && { subscriber_price: priceData.subscriberPrice }),
-                    }),
-                },
-            },
-            { fullPrice: { columnName: 'full_price' } },
-            { subscriberDiscountPercentage: { columnName: 'subscriber_discount_percentage' } },
-            { subscriberPrice: { columnName: 'subscriber_price' } },
-            'published',
-            'sku',
-            {
-                stock: {
-                    columnName: 'stock',
-                    from: (quantity) => ({ quantity }),
-                    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' } },
-            {
-                category: {
-                    columnName: 'category',
-                    foreignKeyColumn: { id: 'categoryId' },
-                    fields: ['id', 'name', 'reference', 'slug'],
-                },
-            },
-        ];
-        this.fields = [
-            ...commonFields,
-            {
-                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()) || [],
-                },
-            },
-            {
-                kitProducts: {
-                    columnName: 'kit_products',
-                    foreignKeyColumn: { productId: 'id' },
-                    fields: [
-                        { productId: { columnName: 'product_id' } },
-                        { kitProductId: { columnName: 'kit_product_id' } },
-                        'quantity',
-                        { product: { columnName: 'product', foreignKeyColumn: { id: 'product_id' }, fields: commonFields } },
-                    ],
-                },
-            },
-            {
-                reviews: {
-                    columnName: 'reviews',
-                    foreignKeyColumn: { product_id: 'id' },
-                    fields: this.reviewsFields,
-                },
-            },
-            {
-                metadata: {
-                    columnName: 'metadata',
-                    fields: ['title', 'description'],
-                    bindPersistData: (value) => ({
-                        metadata: { data: value },
-                    }),
-                },
-            },
-        ];
-    }
-    get reviewsFields() {
-        return [
-            'id',
-            'shop',
-            'rate',
-            'author',
-            'email',
-            'location',
-            'review',
-            'status',
-            'title',
-            { personId: { columnName: 'person_id' } },
-            'points',
-            { orderId: { columnName: 'order_id' } },
-            { createdAt: { columnName: 'created_at' } },
-            { updatedAt: { columnName: 'updated_at' } },
-        ];
-    }
-    async create(params) {
-        const { metadata, ...data } = params;
-        const product = await super.create(omit({ ...data, metadata: metadata || { description: null, title: null } }, ['reviews']));
-        try {
-            product.reviews = data.reviews && (await this.updateReviews(+product.id, data));
-        }
-        catch (error) {
-            await this.delete({ id: product.id });
-            throw error;
-        }
-        return product;
-    }
-    async get(identifiers) {
-        const product = Number.isNaN(+identifiers.id)
-            ? (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');
-        product.reviews = product.reviews || (await this.findReviewsByProduct(+product.id));
-        return product;
-    }
-    async find(params) {
-        const { filters, fields, ...options } = params || {};
-        const bindFields = fields ||
-            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,
-                ...(bindFields.includes('price')
-                    ? [
-                        'subscriberPrice',
-                        'subscriberDiscountPercentage',
-                        'fullPrice',
-                    ]
-                    : []),
-            ],
-        });
-    }
-    async getBySlug(slug) {
-        const result = await this.find({
-            filters: {
-                slug,
-            },
-            fields: this.fields.map((field) => typeof field === 'string' ? field : Object.keys(field).shift()),
-            options: {
-                enableCount: false,
-            },
-        });
-        const product = result?.data?.shift();
-        RoundProductPricesHelper.roundProductPrices(product);
-        return product;
-    }
-    async update(params) {
-        const { categories, kitProducts, reviews, id: checkId, rate, metadata, ...data } = params;
-        const plainData = this.paramsToPlain({ id: checkId });
-        const id = await this.getId(plainData.id);
-        const product = await super.update({ id, ...data });
-        product.categories = categories && (await this.updateCategories(+id, { categories }));
-        product.kitProducts = kitProducts && (await this.updateKitProducts(+id, { kitProducts }));
-        product.reviews = reviews && (await this.updateReviews(+id, { reviews }));
-        product.metadata = metadata && (await this.updateMetadata(+id, { metadata }));
-        return product;
-    }
-    async fetchReviews(status) {
-        const reviewsExpression = {
-            status: status === 'pending'
-                ? { [HasuraGraphQLWhere.ISNULL]: true }
-                : { [HasuraGraphQLWhere.EQUALS]: status === 'approved' },
-        };
-        const { product: data } = await this.query('product', ['id', 'name', 'sku', { reviews: { columnName: 'reviews', fields: this.reviewsFields } }], {
-            where: { value: { reviews: reviewsExpression }, type: 'product_bool_exp', required: true },
-        });
-        return data.reduce((reviews, product) => [
-            ...reviews,
-            ...product.reviews
-                .filter((review) => (status === 'pending' && [undefined, null].includes(review.status)) ||
-                (status === 'approved' && review.status === true) ||
-                (status === 'rejected' && review.status === false))
-                .map((review) => ({
-                ...this.bindReviewToModel(review),
-                productId: product.id,
-                productName: product.name,
-                productSku: product.sku,
-            })),
-        ], []);
-    }
-    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'], {
-                where: {
-                    type: 'category_product_bool_exp',
-                    required: true,
-                    value: { product_id: { _eq: productId } },
-                },
-            });
-            return [];
-        }
-        const plainData = this.paramsToPlain({ categories });
-        if (!plainData.categories || plainData.categories.length <= 0)
-            return [];
-        await this.mutation('delete_category_product', ['affected_rows'], {
-            where: {
-                type: 'category_product_bool_exp',
-                required: true,
-                value: { product_id: { _eq: productId } },
-            },
-        });
-        await this.mutation('insert_category_product', ['affected_rows'], {
-            objects: {
-                type: '[category_product_insert_input!]',
-                required: true,
-                value: plainData.categories.map((categoryId) => ({ category_id: categoryId, product_id: productId })),
-            },
-        });
-        return plainData.categories;
-    }
-    async updateKitProducts(productId, { kitProducts }) {
-        const plainData = this.paramsToPlain({ kitProducts });
-        await this.mutation('delete_product_kit', ['affected_rows'], {
-            where: {
-                type: 'product_kit_bool_exp',
-                required: true,
-                value: { kit_product_id: { _eq: productId } },
-            },
-        });
-        await this.mutation('insert_product_kit', ['affected_rows'], {
-            objects: {
-                type: '[product_kit_insert_input!]',
-                required: true,
-                value: plainData.kitProducts.map((kitProduct) => ({
-                    kit_product_id: productId,
-                    product_id: kitProduct.productId || kitProduct.product.id,
-                    quantity: kitProduct.quantity,
-                })),
-            },
-        });
-        return plainData.kitProducts;
-    }
-    async updateReviews(productId, { reviews }) {
-        if (!reviews)
-            return [];
-        if ('action' in reviews && reviews.action === 'remove') {
-            const reviewIds = await Promise.all(reviews.value.map(async (reviewData) => {
-                const review = await this.findReview(reviewData, productId);
-                return review?.id;
-            }));
-            await this.mutation('delete_product_review', ['affected_rows'], {
-                where: { value: { id: { _in: reviewIds.filter(Boolean) } }, type: 'product_review_bool_exp', required: true },
-            });
-            return reviews.value.map((review, index) => !reviewIds[index] && review).filter(Boolean);
-        }
-        const plainData = this.paramsToPlain({ reviews });
-        if (!plainData.reviews || plainData.reviews.length <= 0)
-            return [];
-        return Promise.all(plainData.reviews.map(async (reviewData) => {
-            const review = await this.findReview(reviewData, productId);
-            if (review.id)
-                return this.bindReviewToModel((await this.mutation('update_product_review_by_pk', this.reviewsFields, {
-                    pk_columns: {
-                        value: { id: review.id },
-                        type: 'product_review_pk_columns_input',
-                        required: true,
-                    },
-                    _set: {
-                        value: omit(this.bindReviewToHasura(reviewData), ['id', 'product_id']),
-                        type: 'product_review_set_input',
-                        required: true,
-                    },
-                })).update_product_review_by_pk);
-            return this.bindReviewToModel((await this.mutation('insert_product_review_one', this.reviewsFields, {
-                object: {
-                    value: omit({ ...this.bindReviewToHasura(reviewData), product_id: productId }, ['id']),
-                    type: 'product_review_insert_input',
-                    required: true,
-                },
-            })).insert_product_review_one);
-        }));
-    }
-    async updateMetadata(productId, { metadata }) {
-        const plainData = this.paramsToPlain({ metadata });
-        if (!plainData.metadata)
-            return null;
-        await this.mutation('update_product_metadata_by_pk', ['product_id'], {
-            pk_columns: {
-                value: { product_id: productId },
-                type: 'product_metadata_pk_columns_input',
-                required: true,
-            },
-            _set: {
-                value: omit(metadata, ['product_id']),
-                type: 'product_metadata_set_input',
-                required: true,
-            },
-        });
-        return plainData.metadata;
-    }
-    async getId(id) {
-        if (!Number.isNaN(+id))
-            return 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`);
-    }
-    async findReviewsByProduct(productId) {
-        const { product_review: data } = await this.query('product_review', this.reviewsFields, {
-            where: {
-                value: {
-                    product_id: { _eq: productId },
-                },
-                type: 'product_review_bool_exp',
-                required: true,
-            },
-        });
-        return data && data.map((review) => this.bindReviewToModel(review));
-    }
-    async findReview(review, productId) {
-        if (review.id)
-            return review;
-        let loadedReview;
-        if (review.personId)
-            loadedReview = await this.getReviewByPersonId(review.personId, productId, review.orderId);
-        if (!loadedReview && review.author && review.email)
-            loadedReview = await this.getReviewByAuthorAndEmail(review.author, review.email, productId, review.orderId);
-        return loadedReview || review;
-    }
-    async getReviewByPersonId(personId, productId, orderId) {
-        const { product_review: data } = await this.query('product_review', this.reviewsFields, {
-            where: {
-                value: {
-                    product_id: { _eq: productId },
-                    person_id: { _eq: personId },
-                    ...(orderId && { order_id: { _eq: orderId } }),
-                },
-                type: `product_review_bool_exp`,
-                required: true,
-            },
-        });
-        return data && data[0] && this.bindReviewToModel(data[0]);
-    }
-    async getReviewByAuthorAndEmail(author, email, productId, orderId) {
-        const { product_review: data } = await this.query('product_review', this.reviewsFields, {
-            where: {
-                value: {
-                    product_id: { _eq: productId },
-                    author: { _eq: author },
-                    email: { _eq: email },
-                    ...(orderId && { order_id: { _eq: orderId } }),
-                },
-                type: `product_review_bool_exp`,
-                required: true,
-            },
-        });
-        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, interceptors, }) {
-        super({
-            tableName: 'product',
-            model: VariantHasuraGraphQL,
-            endpoint,
-            authOptions,
-            interceptors,
-            fields: [
-                { id: { columnName: 'id', to: (value) => +value, from: (value) => value.toString() } },
-                { firestoreId: { columnName: 'firestore_id' } },
-                {
-                    productId: {
-                        columnName: 'main_product_id',
-                        to: (value) => +value,
-                        from: (value) => value?.toString(),
-                    },
-                },
-                { EAN: { columnName: 'ean' } },
-                { costPrice: { columnName: 'cost_price' } },
-                {
-                    price: {
-                        columnName: 'price',
-                        from: (price, data) => ({
-                            price,
-                            fullPrice: data.full_price,
-                            subscriberDiscountPercentage: data.subscriber_discount_percentage,
-                            subscriberPrice: data.subscriber_price,
-                        }),
-                        bindFindFilter: (sentence) => {
-                            const filters = Object.values(sentence).shift();
-                            return {
-                                ...((filters?.price || filters?.price === 0) && { price: filters.price }),
-                                ...((filters.fullPrice || filters.fullPrice === 0) && { full_price: filters.fullPrice }),
-                                ...((filters.subscriberDiscountPercentage || filters.subscriberDiscountPercentage === 0) && {
-                                    subscriber_discount_percentage: filters.subscriberDiscountPercentage,
-                                }),
-                                ...((filters.subscriberPrice || filters.subscriberPrice === 0) && {
-                                    subscriber_price: filters.subscriberPrice,
-                                }),
-                            };
-                        },
-                        bindPersistData: (priceData) => ({
-                            ...((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) >= 0 && { subscriber_price: priceData.subscriberPrice }),
-                        }),
-                    },
-                },
-                { fullPrice: { columnName: 'full_price' } },
-                { subscriberDiscountPercentage: { columnName: 'subscriber_discount_percentage' } },
-                { subscriberPrice: { columnName: 'subscriber_price' } },
-                'sku',
-                {
-                    stock: {
-                        columnName: 'stock',
-                        from: (quantity) => ({ quantity }),
-                        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 } },
-                { createdAt: { columnName: 'created_at' } },
-                { updatedAt: { columnName: 'updated_at' } },
-                {
-                    grade: {
-                        columnName: 'grade',
-                        type: HasuraGraphQLColumnType.Jsonb,
-                    },
-                },
-            ],
-        });
-    }
-    async get(identifiers) {
-        const variant = Number.isNaN(+identifiers.id)
-            ? (await this.find({ filters: { firestoreId: identifiers.id } })).data?.[0]
-            : await super.get(identifiers);
-        if (!variant.productId)
-            throw new NotFoundError(`Variant not found, it is a product`);
-        return variant;
-    }
-    async find(params) {
-        const { filters, ...options } = params || {};
-        return super.find({ ...options, filters: { productId: { operator: Where.ISNOTNULL }, ...filters } });
-    }
-    async update(params) {
-        const { productId, id: checkId, ...data } = params;
-        const dataWithProductId = this.paramsToPlain({ id: checkId, productId });
-        const id = await this.getId(dataWithProductId.id);
-        const product = await super.update({ id, ...data });
-        product.productId = dataWithProductId.productId;
-        return product;
-    }
-    async getId(id) {
-        if (!Number.isNaN(+id))
-            return 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, 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