@infrab4a/connect 3.16.0-beta.1 → 4.0.0-beta.10

package/fesm2020/infrab4a-connect.mjs

@@ -0,0 +1,3319 @@
+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 { get as get$1, isString, isNil, isNumber, isDate, set, isObject, isEmpty, chunk, isBoolean, isInteger, isNaN as isNaN$1, omit } from 'lodash';
+export { chunk, isBoolean, isDate, isEmpty, isInteger, isNaN, isNil, isNumber, isObject, isString, now, omit, pick, set } from 'lodash';
+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');
+        return fields.reduce((object, field) => ({ ...object, [field]: this[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);
+
+class Address extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+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()}`,
+            type: CouponTypes.ABSOLUTE,
+            checkoutType: CheckoutTypes.ECOMMERCE,
+            discount: 30,
+            user: userId,
+            useLimit: 1,
+            useLimitPerUser: true,
+            createdAt: new Date(Date.now()),
+            beginAt: new Date(Date.now()),
+            expiresIn: new Date(Date.now() + COUPON_EXPIRATION),
+        });
+    }
+}
+__decorate([
+    Expose({ name: 'checkout_type' }),
+    __metadata("design:type", Number)
+], Coupon.prototype, "checkoutType", void 0);
+__decorate([
+    Expose({ name: 'exclusivity_type' }),
+    __metadata("design:type", Number)
+], Coupon.prototype, "exclusivityType", void 0);
+
+class SubscriptionPlan extends BaseModel {
+    static get identifiersFields() {
+        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 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(() => Address),
+    __metadata("design:type", Address)
+], Subscription.prototype, "shippingAddress", void 0);
+__decorate([
+    Type(() => Address),
+    __metadata("design:type", Address)
+], 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 UserAddress extends Address {
+    static get identifiersFields() {
+        return ['id', 'userId'];
+    }
+}
+
+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(userAuth);
+        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 Category extends BaseModel {
+    identifierFields() {
+        return ['id'];
+    }
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+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 Product extends BaseModel {
+    identifierFields() {
+        return ['id'];
+    }
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+__decorate([
+    Type(() => KitProduct),
+    __metadata("design:type", Array)
+], Product.prototype, "kitProducts", void 0);
+
+class KitProduct extends BaseModel {
+    static get identifiersFields() {
+        return ['productId', 'kitProducId'];
+    }
+}
+__decorate([
+    Type(() => Product),
+    __metadata("design:type", Product)
+], KitProduct.prototype, "kit", void 0);
+__decorate([
+    Type(() => Product),
+    __metadata("design:type", Product)
+], KitProduct.prototype, "product", void 0);
+
+class Variant extends BaseModel {
+    identifierFields() {
+        return ['id'];
+    }
+    static get identifiersFields() {
+        return ['id', 'productId'];
+    }
+}
+
+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 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(() => Address),
+    __metadata("design:type", Address)
+], Checkout.prototype, "shippingAddress", void 0);
+__decorate([
+    Type(() => Address),
+    __metadata("design:type", Address)
+], 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);
+
+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(() => Address),
+    __metadata("design:type", Address)
+], CheckoutSubscription.prototype, "shippingAddress", void 0);
+__decorate([
+    Type(() => Address),
+    __metadata("design:type", Address)
+], 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 Buy2Win extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+__decorate([
+    Type(() => Category),
+    __metadata("design:type", Array)
+], Buy2Win.prototype, "categories", void 0);
+
+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 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) {
+        try {
+            const { data } = await axios({
+                url: `${this.config.url}/${index}`,
+                method: 'GET',
+                headers: { Authorization: `Basic ${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}`,
+            method: 'POST',
+            headers: { Authorization: `Basic ${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}`,
+            method: 'PUT',
+            headers: { Authorization: `Basic ${this.config.credential}` },
+            data,
+        });
+    }
+    async delete(index) {
+        await axios({
+            url: `${this.config.url}/${index}`,
+            method: 'DELETE',
+            headers: { Authorization: `Basic ${this.config.credential}` },
+        });
+    }
+}
+
+class ProductsIndex {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    async get(id) {
+        const data = await this.adapter.get(`products/_doc/${id}`);
+        return Product.toInstance(data);
+    }
+    async findById(ids, options) {
+        const fields = [
+            'brand',
+            'id',
+            'images',
+            'miniatures',
+            'name',
+            'price',
+            'sku',
+            'stock',
+            'slug',
+            'reviews',
+            'pricePaid',
+            'isGift',
+            'stock',
+            'weight',
+            'tags',
+            'hasVariants',
+            'type',
+        ];
+        const { hits } = await this.adapter.query('products/_search', {
+            _source: fields,
+            query: {
+                bool: {
+                    filter: [
+                        {
+                            terms: {
+                                _id: ids,
+                            },
+                        },
+                        {
+                            term: {
+                                published: true,
+                            },
+                        },
+                        ...(options?.hasStock
+                            ? [
+                                {
+                                    range: {
+                                        'stock.quantity': {
+                                            gt: 0,
+                                        },
+                                    },
+                                },
+                            ]
+                            : []),
+                    ],
+                },
+            },
+            ...(options?.size ? { size: options?.size } : {}),
+        });
+        return hits.map((hit) => Product.toInstance(hit._source));
+    }
+    async save(product) {
+        delete product.createdAt;
+        delete product.updatedAt;
+        delete product.kitProducts;
+        try {
+            if (!product.firestoreId)
+                throw new Error('Is not a product from firestore');
+            await this.get(product.firestoreId);
+            await this.adapter.save(`products/_doc/${product.firestoreId}`, product.toPlain());
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            console.error(error.message);
+            await this.adapter.save(`products/_doc/${product.id}`, product.toPlain());
+        }
+    }
+    async delete(product) {
+        if (!product.firestoreId)
+            return;
+        try {
+            await this.get(product.firestoreId);
+            await this.adapter.delete(`products/_doc/${product.firestoreId}`);
+        }
+        catch (error) {
+            await this.adapter.delete(`products/_doc/${product.id}`);
+        }
+    }
+}
+
+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),
+        }), {});
+    };
+    return class extends MixinBase {
+        constructor() {
+            super(...arguments);
+            this.collectionName = '';
+        }
+        collection(path) {
+            return collection(this.firestore, path || this.collectionName).withConverter(this.buildModelInstance());
+        }
+        buildModelInstance() {
+            return {
+                toFirestore: (data) => (data?.toPlain ? data.toPlain() : data),
+                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 docRef = await getDoc(doc(await this.collection(this.buildCollectionPathForGet(identifiers)), Object.values(identifiers).shift().toString()));
+            const data = docRef.data();
+            if (isNil(data))
+                throw new NotFoundError(`Document ${JSON.stringify(identifiers)} not found`);
+            return 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)
+                    [];
+                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({ filters, limits, orderBy, } = {}) {
+            const collection = this.collection(this.buildCollectionPathForFind(filters));
+            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,
+                count: this.calculateCount(data, limits),
+            };
+        }
+        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)), limits.offset.identifier[limits.offset.identifiersFields?.shift()]))));
+                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 docRef = await this.save(this.model.toInstance(data));
+            const doc = await getDoc(docRef);
+            return doc.data();
+        }
+        async save(data) {
+            const id = data.identifier[data.identifiersFields?.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());
+            await setDoc(docRef, this.paramsToPlain(data), { merge: true });
+            const docData = await getDoc(docRef);
+            return docData.data();
+        }
+        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) {
+            await deleteDoc(doc(this.collection(this.buildCollectionPathForRemove(identifiers)), Object.values(identifiers).shift().toString()));
+        }
+        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(...args) {
+            super(args);
+        }
+        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) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'leads';
+        this.model = Lead;
+    }
+}
+
+class SubscriptionEditionFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), Subscription) {
+    constructor(firestore, parentRepository) {
+        super();
+        this.firestore = firestore;
+        this.parentRepository = parentRepository;
+        this.collectionName = 'editions';
+        this.parentIdField = 'subscriptionId';
+        this.model = Edition;
+    }
+}
+
+class SubscriptionFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'subscription';
+        this.model = Subscription;
+    }
+}
+
+class SubscriptionPaymentFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), Subscription) {
+    constructor(firestore, parentRepository) {
+        super();
+        this.firestore = firestore;
+        this.parentRepository = parentRepository;
+        this.collectionName = 'payments';
+        this.parentIdField = 'subscriptionId';
+        this.model = SubscriptionPayment;
+    }
+}
+
+class UserAddressFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), User) {
+    constructor(firestore, parentRepository) {
+        super();
+        this.firestore = firestore;
+        this.parentRepository = parentRepository;
+        this.collectionName = 'address';
+        this.parentIdField = 'userId';
+        this.model = UserAddress;
+    }
+}
+
+class UserBeautyProfileFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), User) {
+    constructor(firestore, parentRepository) {
+        super();
+        this.firestore = firestore;
+        this.parentRepository = parentRepository;
+        this.collectionName = 'CX';
+        this.parentIdField = 'userId';
+        this.model = BeautyProfile;
+    }
+}
+
+class UserFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'users';
+        this.model = User;
+    }
+    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, parentRepository) {
+        super();
+        this.firestore = firestore;
+        this.parentRepository = parentRepository;
+        this.collectionName = 'payment_method';
+        this.parentIdField = 'userId';
+        this.model = UserPaymentMethod;
+    }
+}
+
+class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'categories';
+        this.model = Category;
+    }
+    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) {
+        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 }),
+        })));
+        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?.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);
+    }
+}
+
+class ProductFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.reviews = {};
+        this.collectionName = 'productsErpVitrine';
+        this.model = Product;
+    }
+    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];
+    }
+}
+
+class ProductVariantFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), Product) {
+    constructor(firestore, parentRepository) {
+        super();
+        this.firestore = firestore;
+        this.parentRepository = parentRepository;
+        this.collectionName = 'variants';
+        this.parentIdField = 'productId';
+        this.model = Variant;
+    }
+}
+
+class SubscriptionProductFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'subscriptionProducts';
+        this.model = Product;
+    }
+}
+
+class CheckoutFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'checkouts';
+        this.model = Checkout;
+    }
+}
+
+class CouponFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'coupons';
+        this.model = Coupon;
+    }
+    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) {
+        super();
+        this.firestore = firestore;
+        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;
+        };
+        this.collectionName = 'orders';
+        this.model = Order;
+        this.fields = {
+            status: FirestoreFieldType.String,
+        };
+    }
+    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 PaymentFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'payments';
+        this.model = Payment;
+    }
+}
+
+class CheckoutSubscriptionFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'checkoutsSubscription';
+        this.model = CheckoutSubscription;
+    }
+}
+
+class SubscriptionPlanFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'subscriptionPlans';
+        this.model = SubscriptionPlan;
+    }
+}
+
+class Buy2WinFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'buy2win';
+        this.model = Buy2Win;
+    }
+}
+
+class LegacyOrderFirestoreRepository extends OrderFirestoreRepository {
+    constructor(firestore) {
+        super(firestore);
+        this.firestore = firestore;
+        this.collectionName = 'legacyOrders';
+    }
+}
+
+class HomeFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.homeToFirestore = (home) => {
+            if (home.data?.data) {
+                home.data.data.discoverProducts = home.data.data.discoverProducts.map(this.homeCategoryGroupToPlain);
+                home.data.data.featuredProducts = home.data.data.featuredProducts.map(this.homeCategoryGroupToPlain);
+                home.data.data.verticalProducts = home.data.data.verticalProducts.map(this.homeCategoryGroupToPlain);
+            }
+            return home;
+        };
+        this.homeCategoryGroupToPlain = (homeCategoryGroup) => ({
+            category: homeCategoryGroup.category.toPlain(),
+            products: homeCategoryGroup.products.map((product) => product.toPlain()),
+        });
+        this.homeFromFirestore = (home) => {
+            if (home.data?.data) {
+                home.data.data.discoverProducts = home.data.data.discoverProducts.map(this.plainToHomeCategoryGroup);
+                home.data.data.featuredProducts = home.data.data.featuredProducts.map(this.plainToHomeCategoryGroup);
+                home.data.data.verticalProducts = home.data.data.verticalProducts.map(this.plainToHomeCategoryGroup);
+                home.data.createdAt =
+                    home.data.createdAt instanceof Timestamp ? home.data.createdAt.toDate() : home.data.createdAt;
+                home.data.expiresAt =
+                    home.data.expiresAt instanceof Timestamp ? home.data.expiresAt.toDate() : home.data.expiresAt;
+            }
+            return home;
+        };
+        this.plainToHomeCategoryGroup = (homeCategoryGroup) => ({
+            category: Category.toInstance(homeCategoryGroup.category),
+            products: homeCategoryGroup.products.map((product) => Product.toInstance(product)),
+        });
+        this.collectionName = 'dms';
+        this.model = Home;
+    }
+    buildModelInstance() {
+        const { fromFirestore, toFirestore } = super.buildModelInstance();
+        return {
+            toFirestore: (data) => {
+                const modifiedData = this.homeToFirestore(data);
+                return toFirestore(modifiedData);
+            },
+            fromFirestore: (snap) => {
+                const instance = fromFirestore(snap);
+                return this.homeFromFirestore(instance);
+            },
+        };
+    }
+}
+
+class ShopMenuFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'shopMenus';
+        this.model = ShopMenu;
+    }
+}
+
+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 };
+    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);
+    if (!Array.isArray(options) &&
+        isObject(options) &&
+        isNil(options?.operator) &&
+        isNil(options?.value) &&
+        isNil(fieldSentenceOptions?.to))
+        return Object.keys(options).reduce((variables, key) => {
+            const fieldOptions = AttributeOptionHelper.FindByAttribute(key, fieldSentenceOptions?.fields || fields);
+            const columnName = fieldOptions.columnName;
+            const columnFields = fieldOptions.fields;
+            return {
+                ...variables,
+                [columnName]: BindFilterQueryHelper.BuildWhereSentence(key, is(is(options)[key]), columnFields || []),
+            };
+        }, {});
+    if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))
+        return {
+            [fieldSentenceOptions.fields[0]]: BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions),
+        };
+    if (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 = field[fieldName];
+        if (Array.isArray(fieldValue))
+            return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) };
+        if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue))
+            return null;
+        if (fieldValue.fields)
+            return !fieldValue.filters
+                ? {
+                    [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+                }
+                : {
+                    operation: fieldValue.columnName || fieldName,
+                    fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+                    variables: {
+                        [`${fieldValue.columnName}_where`]: {
+                            name: 'where',
+                            type: fieldValue.filters.filterType,
+                            value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),
+                            required: true,
+                        },
+                    },
+                };
+        return 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]: parseDateTime(data[columnName]?.toString()) };
+}, {});
+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) => ({
+                ...object,
+                [foreignKeyColumn[current]]: 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] };
+    }, {});
+};
+
+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) {
+            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),
+                    {
+                        [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) {
+            const instance = this.model.toInstance(identifiers);
+            await this.mutation(this.deleteGraphQLOperation, this.model.identifiersFields.map((field) => AttributeOptionHelper.FindByAttribute(field, this.fields).columnName), this.model.identifiersFields.reduce((ids, identifier) => {
+                if (isNil(instance[identifier]))
+                    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;
+        }
+        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, 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) {
+            const headers = this.headers;
+            const response = await axios.post(`${this.endpoint}`, params, {
+                headers,
+            });
+            const result = await response.data;
+            if (!isNil(result.errors))
+                throw new Error(JSON.stringify(result.errors));
+            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) {
+            const plain = GraphQLFieldHelper.ConvertFieldValueFrom(data, 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) {
+            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) => {
+                if (isNil(instance[identifier]))
+                    return ids;
+                const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields);
+                const value = columnOption?.to?.(data[identifier], 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) {
+            const instance = this.model.toInstance(identifiers);
+            const result = await this.query(this.getGraphQLOperation, this.fields, this.model.identifiersFields.reduce((ids, identifier) => {
+                if (isNil(instance[identifier]))
+                    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 {
+        async find(options) {
+            const { filters, limits, orderBy } = options || {};
+            const variablesCount = {
+                ...(isNil(orderBy) ? {} : { order_by: { type: `${this.tableName}_order_by!`, list: true, value: orderBy } }),
+                ...(isNil(filters)
+                    ? {}
+                    : {
+                        where: {
+                            value: BindFilterQueryHelper.MakeGraphQLWhere(filters, this.fields),
+                            type: `${this.tableName}_bool_exp`,
+                            required: true,
+                        },
+                    }),
+            };
+            const variables = {
+                ...(isNil(limits) ? {} : limits),
+                ...variablesCount,
+            };
+            const result = await this.query([
+                {
+                    operation: this.tableName,
+                    fields: options.fields
+                        ? options.fields
+                            .map((fieldName) => this.fields.find((fieldOption) => fieldOption === fieldName) ??
+                            this.fields.find((fieldOption) => Object.keys(fieldOption).shift() === fieldName))
+                            .filter(Boolean)
+                        : this.fields,
+                    variables,
+                },
+                {
+                    operation: `${this.tableName}_aggregate`,
+                    fields: [{ aggregate: ['count'] }],
+                    variables: variablesCount,
+                },
+            ]);
+            const data = result[this.tableName].map((row) => this.convertDataFromHasura(row));
+            const count = result[`${this.tableName}_aggregate`].aggregate.count;
+            return { count, data };
+        }
+    };
+};
+
+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 CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, }, productRepository) {
+        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',
+                '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',
+                { 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 },
+                        }),
+                    },
+                },
+            ],
+        });
+        this.productRepository = productRepository;
+    }
+    async create(params) {
+        const { metadata, ...data } = params;
+        return super.create({ ...data, metadata: metadata || { description: null, title: null } });
+    }
+    async get(identifiers) {
+        return Number.isNaN(+identifiers.id)
+            ? (await this.find({ filters: { firestoreId: identifiers.id } })).data?.[0]
+            : super.get(identifiers);
+    }
+    async update(params) {
+        const { products, id: checkId, metadata, ...data } = params;
+        const plainData = this.paramsToPlain({ id: checkId });
+        const id = await this.getId(plainData.id);
+        const category = await super.update({ id, ...data });
+        category.products = products && (await this.updateProducts(+id, { products }));
+        category.metadata = metadata && (await this.updateMetadata(+id, { metadata }));
+        return category;
+    }
+    async getCategoryBySlug(slug, shop) {
+        if (!slug)
+            return null;
+        const { data, count } = await this.find({ filters: { slug, shop, published: true } });
+        if (count > 1)
+            throw new DuplicatedResultsError('Query returned duplicated values');
+        if (!count)
+            throw new NotFoundError(`Category with slug ${slug} not found`);
+        return data.shift();
+    }
+    async getCategoriesForHome(categoryIds, limit = 4) {
+        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 }),
+        })));
+        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 } } } : {}),
+            },
+            fields: [
+                'id',
+                'name',
+                'slug',
+                'images',
+                'miniatures',
+                'price',
+                'fullPrice',
+                'subscriberDiscountPercentage',
+                'subscriberPrice',
+                'stock',
+                'published',
+                'CEST',
+                'EAN',
+                'NCM',
+                'brand',
+                'costPrice',
+                'hasVariants',
+                'isKit',
+                'sku',
+                'rate',
+                'tags',
+                'type',
+                'shoppingCount',
+            ],
+            ...(options?.limit ? { limits: { limit: options?.limit } } : {}),
+        });
+        products.push(...productsData);
+        return products;
+    }
+    async getId(id) {
+        if (!Number.isNaN(+id))
+            return id;
+        const { data } = await this.find({ filters: { firestoreId: id } });
+        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;
+    }
+}
+
+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,
+                    }),
+                    bindFindFilter: (sentence) => {
+                        const filters = Object.values(sentence).shift();
+                        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,
+                            }),
+                        };
+                    },
+                    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 }),
+                    }),
+                },
+            },
+            { differentials: { columnName: 'differentials' } },
+            { whoMustUse: { columnName: 'who_must_use' } },
+            { howToUse: { columnName: 'how_to_use' } },
+            { brandDescription: { columnName: 'brand_description' } },
+            { 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: (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 && { 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),
+                },
+            },
+            'slug',
+            'type',
+            'video',
+            'weight',
+            'gender',
+            { tags: { columnName: 'tags', type: HasuraGraphQLColumnType.Jsonb } },
+            { isKit: { columnName: 'is_kit' } },
+            { createdAt: { columnName: 'created_at' } },
+            { updatedAt: { columnName: 'updated_at' } },
+            {
+                rate: {
+                    columnName: 'reviews_aggregate',
+                    filters: {
+                        filters: { status: true },
+                        filterType: 'product_review_bool_exp',
+                    },
+                    fields: [{ aggregate: [{ avg: ['rate'] }] }],
+                    from: (value) => value.aggregate.avg.rate,
+                },
+            },
+            { shoppingCount: { columnName: 'shopping_count' } },
+        ];
+        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 } })).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');
+        return super.find({
+            ...options,
+            filters: { ...filters, productId: { operator: Where.ISNULL } },
+            fields: bindFields,
+        });
+    }
+    async getBySlug(slug) {
+        const result = await this.find({
+            filters: {
+                slug,
+            },
+        });
+        const product = result?.data?.shift();
+        product.reviews = await this.findReviewsByProduct(+product.id);
+        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 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 } });
+        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]);
+    }
+}
+
+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),
+                    },
+                },
+                '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 } });
+        if (data?.[0]?.id)
+            return data?.[0]?.id;
+        throw new NotFoundError(`Product with id ${id} not found`);
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AccessoryImportances, Address, Area, Authentication, AuthenticationFirebaseAuthService, AxiosAdapter, Base, BaseModel, BeardProblems, BeardSizes, BeautyProductImportances, BeautyProfile, BeautyQuestionsHelper, BillingStatus, BodyProblems, BodyShapes, BodyTattoos, Buy2Win, Buy2WinFirestoreRepository, Category, CategoryFirestoreRepository, CategoryHasuraGraphQL, CategoryHasuraGraphQLRepository, Checkout, CheckoutFirestoreRepository, CheckoutSubscription, CheckoutSubscriptionFirestoreRepository, CheckoutTypes, Coupon, CouponFirestoreRepository, CouponSubtypes, CouponTypes, DuplicatedResultsError, Edition, EditionStatus, Exclusivities, FaceSkinOilinesses, FaceSkinProblems, FaceSkinTones, FamilyIncomes, FilterType, FragranceImportances, GenderDestination, HairColors, HairProblems, HairStrands, HairTypes, Home, HomeFirestoreRepository, InvalidArgumentError, KitProduct, KitProductHasuraGraphQL, Lead, LeadFirestoreRepository, LegacyOrderFirestoreRepository, LineItem, NotFoundError, OfficePosition, Order, OrderFirestoreRepository, OrderStatus, Payment, PaymentFirestoreRepository, PaymentType, Product, ProductFirestoreRepository, ProductHasuraGraphQL, ProductHasuraGraphQLRepository, ProductSpents, ProductVariantFirestoreRepository, ProductsIndex, QuestionsFilters, RecoveryPassword, Register, RegisterFirebaseAuthService, RequiredArgumentError, ShippingMethod, ShopMenu, ShopMenuFirestoreRepository, Shops, SignInMethods, SignOut, Status, Subscription, SubscriptionEditionFirestoreRepository, SubscriptionFirestoreRepository, SubscriptionPayment, SubscriptionPaymentFirestoreRepository, SubscriptionPlan, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, UnauthorizedError, UpdateOptionActions, User, UserAddress, UserAddressFirestoreRepository, UserAlreadyRegisteredError, UserBeautyProfileFirestoreRepository, UserFirestoreRepository, UserPaymentMethod, UserPaymentMethodFirestoreRepository, UserType, Variant, VariantHasuraGraphQL, VariantHasuraGraphQLRepository, WeakPasswordError, Where, get, is, isUUID, parseDateTime, withCreateFirestore, withCreateHasuraGraphQL, withCrudFirestore, withCrudHasuraGraphQL, withDeleteFirestore, withDeleteHasuraGraphQL, withFindFirestore, withFindHasuraGraphQL, withFirestore, withGetFirestore, withGetHasuraGraphQL, withHasuraGraphQL, withHelpers, withSubCollection, withUpdateFirestore, withUpdateHasuraGraphQL };
+//# sourceMappingURL=infrab4a-connect.mjs.map