@infrab4a/connect 5.3.0-beta.3 → 5.3.0-beta.30

package/index.cjs.js

@@ -6,6 +6,7 @@ require('reflect-metadata');
 var tslib = require('tslib');
 var classTransformer = require('class-transformer');
 var dateFns = require('date-fns');
+var dateFnsTz = require('date-fns-tz');
 var lodash = require('lodash');
 var debug = require('debug');
 var serializeJavascript = require('serialize-javascript');
@@ -61,6 +62,18 @@ exports.OrderBlockedType = void 0;
     OrderBlockedType["Boleto"] = "Boleto";
 })(exports.OrderBlockedType || (exports.OrderBlockedType = {}));
 
+exports.OrderPaymentStatus = void 0;
+(function (OrderPaymentStatus) {
+    OrderPaymentStatus["Em processamento"] = "processing";
+    OrderPaymentStatus["Autorizada"] = "authorized";
+    OrderPaymentStatus["Pago"] = "paid";
+    OrderPaymentStatus["Estornada"] = "refunded";
+    OrderPaymentStatus["Aguardando pagamento"] = "waiting_payment";
+    OrderPaymentStatus["Aguardando estorno"] = "pending_refund";
+    OrderPaymentStatus["Recusada/N\u00E3o autorizada"] = "refused";
+    OrderPaymentStatus["Chargedback"] = "chargedback";
+})(exports.OrderPaymentStatus || (exports.OrderPaymentStatus = {}));
+
 exports.PagarmePaymentStatus = void 0;
 (function (PagarmePaymentStatus) {
     PagarmePaymentStatus["Em processamento"] = "processing";
@@ -73,6 +86,33 @@ exports.PagarmePaymentStatus = void 0;
     PagarmePaymentStatus["Chargedback"] = "chargedback";
 })(exports.PagarmePaymentStatus || (exports.PagarmePaymentStatus = {}));
 
+exports.PagarMeV5PaymentStatus = void 0;
+(function (PagarMeV5PaymentStatus) {
+    PagarMeV5PaymentStatus["Em processamento"] = "processing";
+    PagarMeV5PaymentStatus["Gerado"] = "generated";
+    PagarMeV5PaymentStatus["Visualizado"] = "viewed";
+    PagarMeV5PaymentStatus["Pago a menor"] = "underpaid";
+    PagarMeV5PaymentStatus["Pago a maior"] = "overpaid";
+    PagarMeV5PaymentStatus["Aguardando pagamento"] = "waiting_payment";
+    PagarMeV5PaymentStatus["Pago"] = "paid";
+    PagarMeV5PaymentStatus["Aguardando estorno"] = "pending_refund";
+    PagarMeV5PaymentStatus["Autorizada pendente de captura"] = "authorized_pending_capture";
+    PagarMeV5PaymentStatus["N\u00E3o autorizada"] = "not_authorized";
+    PagarMeV5PaymentStatus["Capturada"] = "captured";
+    PagarMeV5PaymentStatus["Aguardando captura"] = "waiting_capture";
+    PagarMeV5PaymentStatus["Com erro"] = "with_error";
+    PagarMeV5PaymentStatus["Estornado"] = "refunded";
+    PagarMeV5PaymentStatus["Cancelado"] = "voided";
+    PagarMeV5PaymentStatus["Falha"] = "failed";
+})(exports.PagarMeV5PaymentStatus || (exports.PagarMeV5PaymentStatus = {}));
+exports.PagarMeV5OrderStatus = void 0;
+(function (PagarMeV5OrderStatus) {
+    PagarMeV5OrderStatus["Pendente"] = "pending";
+    PagarMeV5OrderStatus["Pago"] = "paid";
+    PagarMeV5OrderStatus["Cancelado"] = "canceled";
+    PagarMeV5OrderStatus["Falha"] = "failed";
+})(exports.PagarMeV5OrderStatus || (exports.PagarMeV5OrderStatus = {}));
+
 exports.PaymentMethods = void 0;
 (function (PaymentMethods) {
     PaymentMethods["CARD"] = "card";
@@ -86,8 +126,16 @@ exports.PaymentProviders = void 0;
     PaymentProviders["PAGARME"] = "pagarMe";
     PaymentProviders["ADYEN"] = "adyen";
     PaymentProviders["GLAMPOINTS"] = "glampoints";
+    PaymentProviders["MERCADOPAGO"] = "mercadoPago";
 })(exports.PaymentProviders || (exports.PaymentProviders = {}));
 
+exports.TransactionPaymentMethods = void 0;
+(function (TransactionPaymentMethods) {
+    TransactionPaymentMethods["CARD"] = "credit_card";
+    TransactionPaymentMethods["BANKSLIP"] = "boleto";
+    TransactionPaymentMethods["PIX"] = "pix";
+})(exports.TransactionPaymentMethods || (exports.TransactionPaymentMethods = {}));
+
 class BasePaymentMethodFactory {
     constructor(methods) {
         this.methods = methods;
@@ -112,6 +160,9 @@ class AntifraudProviderFactory {
 class GlampointsPaymentMethodFactory extends BasePaymentMethodFactory {
 }
 
+class MercadoPagoPaymentMethodFactory extends BasePaymentMethodFactory {
+}
+
 class PagarmePaymentMethodFactory extends BasePaymentMethodFactory {
 }
 
@@ -664,6 +715,8 @@ exports.Shops = void 0;
     Shops["MENSMARKET"] = "mensmarket";
     Shops["GLAMSHOP"] = "Glamshop";
     Shops["GLAMPOINTS"] = "Glampoints";
+    Shops["GLAMBEAUTY"] = "Glambeauty";
+    Shops["ELLA"] = "ella";
     Shops["ALL"] = "ALL";
 })(exports.Shops || (exports.Shops = {}));
 
@@ -698,12 +751,36 @@ class Category extends BaseModel {
                 image: null,
             };
     }
+    get glamBeautyImages() {
+        return this.images?.[exports.Shops.GLAMBEAUTY]
+            ? this.images[exports.Shops.GLAMBEAUTY]
+            : {
+                brandBanner: null,
+                brandBannerMobile: null,
+                image: null,
+            };
+    }
+    get ellaImages() {
+        return this.images?.[exports.Shops.ELLA]
+            ? this.images[exports.Shops.ELLA]
+            : {
+                brandBanner: null,
+                brandBannerMobile: null,
+                image: null,
+            };
+    }
     get glamMetadata() {
         return this.metadatas.find((metadata) => metadata.shop === exports.Shops.GLAMSHOP);
     }
     get mensMetadata() {
         return this.metadatas.find((metadata) => metadata.shop === exports.Shops.MENSMARKET);
     }
+    get glamBeautyMetadata() {
+        return this.metadatas.find((metadata) => metadata.shop === exports.Shops.GLAMBEAUTY);
+    }
+    get ellaMetadata() {
+        return this.metadatas.find((metadata) => metadata.shop === exports.Shops.ELLA);
+    }
     getMostRelevantByShop(shop) {
         return this.mostRelevants?.[shop] || [];
     }
@@ -722,6 +799,30 @@ tslib.__decorate([
 ], Category.prototype, "filters", void 0);
 registerClass('Category', Category);
 
+class BrandCategory extends BaseModel {
+    get glamImages() {
+        return this.images?.[exports.Shops.GLAMSHOP]
+            ? this.images[exports.Shops.GLAMSHOP]
+            : {
+                brandBanner: null,
+                brandBannerMobile: null,
+                image: null,
+            };
+    }
+    get mensImages() {
+        return this.images?.[exports.Shops.MENSMARKET]
+            ? this.images[exports.Shops.MENSMARKET]
+            : {
+                brandBanner: null,
+                brandBannerMobile: null,
+                image: null,
+            };
+    }
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
 class CategoryCollectionChildren extends BaseModel {
     static get identifiersFields() {
         return ['collectionId', 'categoryId'];
@@ -795,6 +896,11 @@ class ProductReview extends BaseModel {
         return ['id'];
     }
 }
+tslib.__decorate([
+    classTransformer.Type(resolveClass('Product')),
+    tslib.__metadata("design:type", Function)
+], ProductReview.prototype, "product", void 0);
+registerClass('ProductReview', ProductReview);
 
 class ProductBase extends BaseModel {
     get evaluation() {
@@ -859,28 +965,6 @@ tslib.__decorate([
     tslib.__metadata("design:type", Object)
 ], ProductErrors.prototype, "product", void 0);
 
-class ProductStockNotification extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class Wishlist extends Category {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class Buy2Win extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-tslib.__decorate([
-    classTransformer.Type(() => Category),
-    tslib.__metadata("design:type", Array)
-], Buy2Win.prototype, "categories", void 0);
-
 exports.Where = void 0;
 (function (Where) {
     Where["EQUALS"] = "==";
@@ -907,6 +991,46 @@ exports.UpdateOptionActions = void 0;
     UpdateOptionActions["NULL"] = "null";
 })(exports.UpdateOptionActions || (exports.UpdateOptionActions = {}));
 
+class ProductGroup extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class ProductPriceLog extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class ProductStockEntry extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class ProductStockNotification extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class Wishlist extends Category {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class Buy2Win extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+tslib.__decorate([
+    classTransformer.Type(() => Category),
+    tslib.__metadata("design:type", Array)
+], Buy2Win.prototype, "categories", void 0);
+
 class CampaignDashboard extends BaseModel {
     static get identifiersFields() {
         return ['id'];
@@ -1593,8 +1717,38 @@ exports.OrderStatus = void 0;
     OrderStatus["ENTREGUE"] = "Entregue";
     OrderStatus["CANCELADO"] = "Cancelado";
     OrderStatus["PENDENTE_REENVIO"] = "Pendente reenvio";
+    OrderStatus["AGUARDANDO_STOCK_REENVIO"] = "Aguardando stock para reenvio";
 })(exports.OrderStatus || (exports.OrderStatus = {}));
 
+exports.ShoppingRecurrenceCycle = void 0;
+(function (ShoppingRecurrenceCycle) {
+    ShoppingRecurrenceCycle[ShoppingRecurrenceCycle["MONTHLY"] = 1] = "MONTHLY";
+    ShoppingRecurrenceCycle[ShoppingRecurrenceCycle["BIMONTHLY"] = 2] = "BIMONTHLY";
+    ShoppingRecurrenceCycle[ShoppingRecurrenceCycle["QUARTERLY"] = 3] = "QUARTERLY";
+})(exports.ShoppingRecurrenceCycle || (exports.ShoppingRecurrenceCycle = {}));
+
+exports.ShoppingRecurrenceEditionStatus = void 0;
+(function (ShoppingRecurrenceEditionStatus) {
+    ShoppingRecurrenceEditionStatus["SCHEDULED"] = "scheduled";
+    ShoppingRecurrenceEditionStatus["PAUSED"] = "paused";
+    ShoppingRecurrenceEditionStatus["SKIPPED"] = "skipped";
+    ShoppingRecurrenceEditionStatus["PROCESSING"] = "processing";
+    ShoppingRecurrenceEditionStatus["FINISHED"] = "finished";
+    ShoppingRecurrenceEditionStatus["PAYMENT_FAIL"] = "payment_fail";
+    ShoppingRecurrenceEditionStatus["AWAITING_PAYMENT"] = "awaiting_payment";
+    ShoppingRecurrenceEditionStatus["STOCK_VALIDATION"] = "stock_validation";
+    ShoppingRecurrenceEditionStatus["CANCELLED"] = "cancelled";
+})(exports.ShoppingRecurrenceEditionStatus || (exports.ShoppingRecurrenceEditionStatus = {}));
+
+exports.ShoppingRecurrenceStatus = void 0;
+(function (ShoppingRecurrenceStatus) {
+    ShoppingRecurrenceStatus["ACTIVE"] = "active";
+    ShoppingRecurrenceStatus["PAUSED"] = "paused";
+    ShoppingRecurrenceStatus["CANCELLED"] = "cancelled";
+    ShoppingRecurrenceStatus["PAYMENT_FAILED"] = "payment_failed";
+    ShoppingRecurrenceStatus["WAITING_STOCK"] = "waiting_stock";
+})(exports.ShoppingRecurrenceStatus || (exports.ShoppingRecurrenceStatus = {}));
+
 class Order extends Checkout {
 }
 tslib.__decorate([
@@ -1608,6 +1762,44 @@ class OrderBlocked extends BaseModel {
     }
 }
 
+class ShoppingRecurrence extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+tslib.__decorate([
+    classTransformer.Type(() => User),
+    tslib.__metadata("design:type", User)
+], ShoppingRecurrence.prototype, "user", void 0);
+tslib.__decorate([
+    classTransformer.Type(() => UserAddress),
+    tslib.__metadata("design:type", UserAddress)
+], ShoppingRecurrence.prototype, "shippingAddress", void 0);
+tslib.__decorate([
+    classTransformer.Type(() => UserAddress),
+    tslib.__metadata("design:type", UserAddress)
+], ShoppingRecurrence.prototype, "billingAddress", void 0);
+tslib.__decorate([
+    classTransformer.Type(() => ShippingMethod),
+    tslib.__metadata("design:type", ShippingMethod)
+], ShoppingRecurrence.prototype, "shipping", void 0);
+tslib.__decorate([
+    classTransformer.Type(() => Coupon),
+    tslib.__metadata("design:type", Coupon)
+], ShoppingRecurrence.prototype, "coupon", void 0);
+
+class ShoppingRecurrenceEdition extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class ShoppingRecurrenceErrorLog extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
 class CheckoutSubscription extends BaseModel {
     static get identifiersFields() {
         return ['id'];
@@ -1630,11 +1822,27 @@ tslib.__decorate([
     tslib.__metadata("design:type", Coupon)
 ], CheckoutSubscription.prototype, "coupon", void 0);
 
+exports.ErrorsCode = void 0;
+(function (ErrorsCode) {
+    ErrorsCode["genericError"] = "generic-error";
+    ErrorsCode["businessError"] = "business-error";
+    ErrorsCode["invalidCheckoutError"] = "invalid-checkout";
+    ErrorsCode["stockLimit"] = "stock-limit";
+    ErrorsCode["stockOut"] = "stock-out";
+    ErrorsCode["notFound"] = "not-found";
+    ErrorsCode["fraudPreventionInternal"] = "fraud-prevention-internal";
+    ErrorsCode["fraudPreventionExternal"] = "fraud-prevention-external";
+    ErrorsCode["invalidCardError"] = "invalid-card-error";
+    ErrorsCode["insufficientFundsError"] = "insufficient-funds-error";
+    ErrorsCode["paymentNotAuthorizedError"] = "payment-not-authorized-error";
+    ErrorsCode["paymentError"] = "payment-error";
+})(exports.ErrorsCode || (exports.ErrorsCode = {}));
+
 class BusinessError extends tsCustomError.CustomError {
-    constructor(message, additionalData, type = '') {
+    constructor(message, additionalData, type) {
         super(message);
         this.additionalData = additionalData;
-        this.type = type;
+        this.type = type || exports.ErrorsCode.businessError;
     }
 }
 
@@ -1645,10 +1853,10 @@ class DuplicatedResultsError extends tsCustomError.CustomError {
 }
 
 class FraudValidationError extends tsCustomError.CustomError {
-    constructor(message, additionalData) {
+    constructor(message, type, additionalData) {
         super(message);
         this.additionalData = additionalData;
-        this.type = 'antifraud';
+        this.type = type;
     }
 }
 
@@ -1658,17 +1866,26 @@ class InvalidArgumentError extends tsCustomError.CustomError {
     }
 }
 
+class InvalidCheckoutError extends tsCustomError.CustomError {
+    constructor(message, additionalData) {
+        super(message);
+        this.additionalData = additionalData;
+        this.type = exports.ErrorsCode.invalidCheckoutError;
+    }
+}
+
 class NotFoundError extends tsCustomError.CustomError {
     constructor(message) {
         super(message);
+        this.type = exports.ErrorsCode.notFound;
     }
 }
 
 class PaymentError extends tsCustomError.CustomError {
-    constructor(message, additionalData) {
+    constructor(message, type, additionalData) {
         super(message);
         this.additionalData = additionalData;
-        this.type = 'payment';
+        this.type = type;
     }
 }
 
@@ -1683,14 +1900,14 @@ class RequiredArgumentError extends tsCustomError.CustomError {
 class StockLimitError extends BusinessError {
     constructor(message, additionalData) {
         super(message, additionalData);
-        this.type = 'stock-limit';
+        this.type = exports.ErrorsCode.stockLimit;
     }
 }
 
 class StockOutError extends BusinessError {
     constructor(message, additionalData) {
         super(message, additionalData);
-        this.type = 'stock-out';
+        this.type = exports.ErrorsCode.stockOut;
     }
 }
 
@@ -1707,7 +1924,7 @@ class AntifraudBankSlipService {
                 type: 'Boleto',
                 limiteRange: 'day',
             });
-            throw new FraudValidationError('Boleto não autorizado para cliente não assinante', {
+            throw new FraudValidationError('Boleto não autorizado para cliente não assinante', exports.ErrorsCode.fraudPreventionInternal, {
                 checkoutId: checkout.id,
                 userEmail: checkout.user.email,
                 info: {
@@ -1725,19 +1942,58 @@ class AntifraudCardService {
     constructor(orderRepository, orderBlockedRepository) {
         this.orderRepository = orderRepository;
         this.orderBlockedRepository = orderBlockedRepository;
-        this.LIMIT_ORDERS_DAY = 2;
-        this.LIMIT_ORDERS_WEEK = 7;
-        this.LIMIT_BLOCKED_ORDERS_DAY = 5;
+        this.LIMIT_ORDERS_DAY = null;
+        this.LIMIT_ORDERS_WEEK = null;
     }
     async validate(checkout, card) {
+        this.setLimitsByUserType(checkout.user.isSubscriber);
         await this.validateBlockedOrderAttempts(checkout, card);
         await this.validateDayAndWeekOrderLimits(checkout, card);
         return true;
     }
+    setLimitsByUserType(isSubscriber) {
+        this.LIMIT_ORDERS_DAY = {
+            subscriber: {
+                cpf: 4,
+                email: 4,
+                phone: 4,
+                card: 4,
+                zip: 4,
+            },
+            nonSubscriber: {
+                cpf: 2,
+                email: 2,
+                phone: 2,
+                card: 2,
+                zip: 2,
+            },
+        };
+        this.LIMIT_ORDERS_WEEK = {
+            subscriber: {
+                cpf: 12,
+                email: 12,
+                phone: 12,
+                card: 12,
+                zip: Infinity,
+            },
+            nonSubscriber: {
+                cpf: 7,
+                email: 7,
+                phone: 7,
+                card: 7,
+                zip: Infinity,
+            },
+        };
+        this.LIMIT_BLOCKED_ORDERS_DAY = isSubscriber ? 7 : 5;
+    }
+    getLimitsByUserType(type, isSubscriber) {
+        const limits = type === 'day' ? this.LIMIT_ORDERS_DAY : this.LIMIT_ORDERS_WEEK;
+        return isSubscriber ? limits['subscriber'] : limits['nonSubscriber'];
+    }
     async validateBlockedOrderAttempts(checkout, card) {
         const isValid = await this.verifyBlockedOrderAttempts(checkout, card);
         if (!isValid) {
-            throw new FraudValidationError('Cliente com mais de 5 compras negadas/bloqueadas no dia', {
+            throw new FraudValidationError(`Cliente com mais de ${this.LIMIT_BLOCKED_ORDERS_DAY} compras negadas/bloqueadas no dia`, exports.ErrorsCode.fraudPreventionInternal, {
                 checkoutId: checkout.id,
                 userEmail: checkout.user.email,
                 info: {
@@ -1751,7 +2007,7 @@ class AntifraudCardService {
     async validateDayAndWeekOrderLimits(checkout, card) {
         const isValid = await this.verifyDayAndWeekOrders(checkout, card);
         if (!isValid) {
-            throw new FraudValidationError('Cliente tentando comprar mais de 2 vezes no dia ou 7 vezes na semana', {
+            throw new FraudValidationError('Cliente tentando comprar mais do que o permitido no dia/semana', exports.ErrorsCode.fraudPreventionInternal, {
                 checkoutId: checkout.id,
                 userEmail: checkout.user.email,
                 info: {
@@ -1770,7 +2026,7 @@ class AntifraudCardService {
             await this.createBlockedOrderRecord({
                 checkout,
                 card,
-                reason: 'More than 5 attempts have failed',
+                reason: `More than ${this.LIMIT_BLOCKED_ORDERS_DAY} attempts have failed`,
                 key: 'Failed attempts',
                 period: 'day',
             });
@@ -1779,15 +2035,17 @@ class AntifraudCardService {
         return true;
     }
     getTodayDateRange() {
-        const day = `${dateFns.format(new Date(), 'yyyy-MM-dd')}T00:00:00`;
-        const endOfDay = `${dateFns.format(new Date(), 'yyyy-MM-dd')}T23:59:59`;
-        return { day, endOfDay };
+        const timeZone = 'America/Sao_Paulo';
+        const today = dateFnsTz.utcToZonedTime(new Date(), timeZone);
+        const day = dateFns.startOfDay(today);
+        const endOfDay = dateFns.endOfDay(today);
+        return { day: dateFns.addHours(day, 3), endOfDay: dateFns.addHours(endOfDay, 3) };
     }
     async getBlockedOrdersByMultipleCriteria(checkout, dateRange) {
         const { day, endOfDay } = dateRange;
         const dateFilter = [
-            { operator: exports.Where.GTE, value: new Date(day) },
-            { operator: exports.Where.LTE, value: new Date(endOfDay) },
+            { operator: exports.Where.GTE, value: day },
+            { operator: exports.Where.LTE, value: endOfDay },
         ];
         const [ordersBlockedWithCpf, ordersBlockedWithEmail, ordersBlockedWithCep, ordersBlockedWithPhone] = await Promise.all([
             this.getBlockedOrdersByCpf(checkout.user?.cpf, dateFilter),
@@ -1889,26 +2147,28 @@ class AntifraudCardService {
     }
     async validateDayOrderLimits(checkout, params) {
         const ordersPerDay = await this.validateOrdersByRange(params, this.getDateRange('day'));
+        const limits = this.getLimitsByUserType('day', checkout.user.isSubscriber);
         return this.checkOrderLimitsAndBlock({
             checkout,
             orderCounts: ordersPerDay,
-            limit: this.LIMIT_ORDERS_DAY,
+            limit: limits,
             period: 'day',
         });
     }
     async validateWeekOrderLimits(checkout, params) {
         const ordersPerWeek = await this.validateOrdersByRange(params, this.getDateRange('week'));
+        const limits = this.getLimitsByUserType('week', checkout.user.isSubscriber);
         return this.checkOrderLimitsAndBlock({
             checkout,
             orderCounts: ordersPerWeek,
-            limit: this.LIMIT_ORDERS_WEEK,
+            limit: limits,
             period: 'week',
         });
     }
     async checkOrderLimitsAndBlock(params) {
         const { checkout, orderCounts, limit, period } = params;
         for (const key in orderCounts) {
-            if (orderCounts[key] >= limit) {
+            if (orderCounts[key] >= limit[key]) {
                 await this.createBlockedOrderRecord({
                     checkout,
                     card: null,
@@ -2174,6 +2434,7 @@ exports.ShopPageName = void 0;
     ShopPageName["LP_GLAMQUEENS"] = "LP_GLAMQUEENS";
     ShopPageName["LP_INVITE"] = "LP_INVITE";
     ShopPageName["LP_LIVELO"] = "LP_LIVELO";
+    ShopPageName["GLAM_NEW_HOME"] = "GLAM_NEW_HOME";
 })(exports.ShopPageName || (exports.ShopPageName = {}));
 
 class BeautyQuestionsHelper {
@@ -2239,16 +2500,100 @@ class Home extends BaseModel {
     }
 }
 
+class ShopConfigs extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
 class ShopMenu extends BaseModel {
     static get identifiersFields() {
         return ['id'];
     }
 }
 
+var ShopPageSectionType;
+(function (ShopPageSectionType) {
+    ShopPageSectionType["LIVE"] = "LIVE";
+    ShopPageSectionType["CAROUSEL"] = "CAROUSEL";
+    ShopPageSectionType["BANNER"] = "BANNER";
+    ShopPageSectionType["INFOBARS"] = "INFOBARS";
+    ShopPageSectionType["HIGHLIGHTS"] = "HIGHLIGHTS";
+    ShopPageSectionType["SUBSCRIBER_INFO"] = "SUBSCRIBER_INFO";
+    ShopPageSectionType["COLLECTION"] = "COLLECTION";
+    ShopPageSectionType["BEAUTY_PROFILE_COLLECTION"] = "BEAUTY_PROFILE_COLLECTION";
+    ShopPageSectionType["PLANS"] = "PLANS";
+    ShopPageSectionType["SINGLE_PLAN"] = "SINGLE_PLAN";
+    ShopPageSectionType["BRANDS"] = "BRANDS";
+    ShopPageSectionType["NEWSLETTER"] = "NEWSLETTER";
+})(ShopPageSectionType || (ShopPageSectionType = {}));
+
+/* eslint-disable max-lines-per-function */
 class ShopSettings extends BaseModel {
     static get identifiersFields() {
         return ['id'];
     }
+    getPageSections(displayRules) {
+        const now = new Date();
+        return (Array.isArray(this.sections) ? this.sections : [])
+            .map((section) => {
+            // Filtra banners dentro de carrousel
+            if (section.type === ShopPageSectionType.CAROUSEL && Array.isArray(section.banners)) {
+                const filteredBanners = section.banners.filter((banner) => {
+                    // Filtra por displayRules
+                    const rulesMatch = banner.displayRules.length
+                        ? banner.displayRules.some((rule) => Object.keys(rule).every((key) => rule[key] === displayRules[key]))
+                        : true;
+                    // Filtra por publishDate e expirationDate
+                    const publishOk = !banner.publishDate || now >= new Date(banner.publishDate);
+                    const expireOk = !banner.expirationDate || now <= new Date(banner.expirationDate);
+                    return rulesMatch && publishOk && expireOk;
+                });
+                return { ...section, banners: filteredBanners };
+            }
+            // Filtra highlights
+            if (section.type === ShopPageSectionType.HIGHLIGHTS && Array.isArray(section.highlights)) {
+                const filteredHighlights = section.highlights.filter((highlight) => {
+                    // Filtra por displayRules
+                    const rulesMatch = highlight.displayRules.length
+                        ? highlight.displayRules.some((rule) => Object.keys(rule).every((key) => rule[key] === displayRules[key]))
+                        : true;
+                    return rulesMatch;
+                });
+                const sortedHighlights = !displayRules.beautyProfile
+                    ? filteredHighlights.sort((a, b) => (a.starred === b.starred ? 0 : a.starred ? -1 : 1))
+                    : filteredHighlights;
+                return { ...section, highlights: sortedHighlights };
+            }
+            // Filtra collections
+            if (section.type === ShopPageSectionType.COLLECTION) {
+                const rulesMatch = section.displayRules.length
+                    ? section.displayRules.some((rule) => Object.keys(rule).every((key) => rule[key] === displayRules[key]))
+                    : true;
+                const publishOk = !section.publishDate || now >= new Date(section.publishDate);
+                const expireOk = !section.expirationDate || now <= new Date(section.expirationDate);
+                return rulesMatch && publishOk && expireOk ? section : null;
+            }
+            // Filtra banners
+            if (section.type === ShopPageSectionType.BANNER) {
+                const rulesMatch = section.displayRules.length
+                    ? section.displayRules.some((rule) => Object.keys(rule).every((key) => rule[key] === displayRules[key]))
+                    : true;
+                const publishOk = !section.publishDate || now >= new Date(section.publishDate);
+                const expireOk = !section.expirationDate || now <= new Date(section.expirationDate);
+                return rulesMatch && publishOk && expireOk ? section : null;
+            }
+            if (section.type === ShopPageSectionType.LIVE) {
+                return section.active ? section : null;
+            }
+            if (section.type === ShopPageSectionType.PLANS || section.type === ShopPageSectionType.SINGLE_PLAN) {
+                return displayRules.notSubscriber ? section : null;
+            }
+            // Demais seções retornam normalmente
+            return section;
+        })
+            .filter(Boolean);
+    }
 }
 
 class AdyenBlockedOrderHelper {
@@ -2260,14 +2605,14 @@ class AdyenBlockedOrderHelper {
             limiteRange: 'day',
             card: params.card,
         });
-        throw new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', {
+        throw new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', exports.ErrorsCode.paymentError, {
             checkoutId: params.checkout.id,
             userEmail: params.checkout.user.email,
             info: params.adyenResponse,
         });
     }
     static createPaymentError(checkout, errorInfo) {
-        return new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', {
+        return new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', exports.ErrorsCode.paymentError, {
             checkoutId: checkout.id,
             userEmail: checkout.user.email,
             info: errorInfo,
@@ -4726,6 +5071,17 @@ const withCrudFirestore = (MixinBase) => {
     };
 };
 
+class BrandCategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, }) {
+        super({
+            firestore,
+            collectionName: 'brandsCategory',
+            model: BrandCategory,
+            interceptors,
+        });
+    }
+}
+
 class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
     constructor({ firestore, interceptors }) {
         super({
@@ -4801,6 +5157,9 @@ class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFire
     isChild(_id, _parentId) {
         return;
     }
+    async getBrandsWithProducts() {
+        return;
+    }
 }
 tslib.__decorate([
     Log(),
@@ -5014,6 +5373,18 @@ class HomeFirestoreRepository extends withCrudFirestore(withHelpers(withFirestor
     }
 }
 
+class ShopConfigsFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, cache, }) {
+        super({
+            firestore,
+            collectionName: 'shopConfigs',
+            model: ShopConfigs,
+            interceptors,
+            cache,
+        });
+    }
+}
+
 class ShopMenuFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
     constructor({ firestore, interceptors, cache, }) {
         super({
@@ -5207,6 +5578,7 @@ class OrderBlockedFirestoreRepository extends withCrudFirestore(withHelpers(with
             card,
             checkout,
             date: new Date(),
+            gatewayInfo: params.gatewayInfo || {},
         }));
     }
     formatZip(zip) {
@@ -5228,6 +5600,74 @@ class PaymentFirestoreRepository extends withCrudFirestore(withHelpers(withFires
     }
 }
 
+class ShoppingRecurrenceEditionFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, cache, }) {
+        super({
+            firestore,
+            collectionName: 'shoppingRecurrenceEditions',
+            model: ShoppingRecurrenceEdition,
+            interceptors,
+            cache,
+        });
+    }
+}
+
+class ShoppingRecurrenceErrorLogFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, cache, }) {
+        super({
+            firestore,
+            collectionName: 'shoppingRecurrenceErrorLogs',
+            model: ShoppingRecurrenceErrorLog,
+            interceptors,
+            cache,
+        });
+    }
+}
+
+class ShoppingRecurrenceFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, cache, }) {
+        super({
+            firestore,
+            collectionName: 'shoppingRecurrences',
+            model: ShoppingRecurrence,
+            interceptors,
+            cache,
+        });
+    }
+    async findByUserId(userId) {
+        const result = await this.find({
+            filters: {
+                user: {
+                    id: userId,
+                },
+            },
+        });
+        return result.data;
+    }
+    async findByUserIdAndStatus(userId, status) {
+        const result = await this.find({
+            filters: {
+                user: {
+                    id: userId,
+                },
+                status,
+            },
+        });
+        return result.data;
+    }
+    async findByUserAndShop(userId, shop) {
+        const result = await this.find({
+            filters: {
+                user: {
+                    id: userId,
+                },
+                shop,
+            },
+        });
+        return result.data;
+    }
+}
+
 class SubscriptionPlanFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
     constructor({ firestore, interceptors, cache, }) {
         super({
@@ -5811,6 +6251,9 @@ tslib.__decorate([
     tslib.__metadata("design:type", Product)
 ], KitProductHasuraGraphQL.prototype, "product", void 0);
 
+class ProductCatalogHasuraGraphQL extends Product {
+}
+
 class ProductHasuraGraphQL extends Product {
 }
 tslib.__decorate([
@@ -5828,6 +6271,9 @@ tslib.__decorate([
     tslib.__metadata("design:type", Object)
 ], ProductErrorsHasuraGraphQL.prototype, "product", void 0);
 
+class ProductStockEntryHasuraGraphQL extends ProductStockEntry {
+}
+
 class CategoryCollectionChildrenHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
     constructor({ endpoint, authOptions, interceptors, cache, }) {
         super({
@@ -6714,6 +7160,8 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
             mostRelevants: mostRelevants || {
                 [exports.Shops.GLAMSHOP]: null,
                 [exports.Shops.MENSMARKET]: null,
+                [exports.Shops.GLAMBEAUTY]: null,
+                [exports.Shops.ELLA]: null,
             },
             images: images || {
                 [exports.Shops.GLAMSHOP]: {
@@ -6726,6 +7174,16 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
                     brandBannerMobile: null,
                     image: null,
                 },
+                [exports.Shops.GLAMBEAUTY]: {
+                    brandBanner: null,
+                    brandBannerMobile: null,
+                    image: null,
+                },
+                [exports.Shops.ELLA]: {
+                    brandBanner: null,
+                    brandBannerMobile: null,
+                    image: null,
+                },
             },
         });
     }
@@ -6899,6 +7357,19 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
             categoryFilterRepository: this.categoryFilterRepository,
         });
     }
+    async getBrandsWithProducts() {
+        const fields = ['id', 'name', 'slug', 'brand_category', 'published', 'images'];
+        const { brands_with_products_query: data, } = await this.query('brands_with_products_query', fields);
+        return data.map((brand) => Category.toInstance({
+            id: brand.id,
+            name: brand.name,
+            slug: brand.slug,
+            brandCategory: brand.brand_category,
+            shops: brand.shops,
+            published: brand.published,
+            images: brand.images,
+        }));
+    }
 }
 tslib.__decorate([
     Log(),
@@ -7013,10 +7484,30 @@ class CategoryProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withH
             },
         });
     }
-}
-
-const fieldsConfiguration$3 = [
-    'id',
+    async removeProductFromAllCategories(productId) {
+        this.logger = DebugHelper.from(this, 'removeProductFromAllCategories');
+        await this.mutation('delete_category_product', ['affected_rows'], {
+            where: {
+                type: 'category_product_bool_exp',
+                required: true,
+                value: { product_id: { _eq: productId } },
+            },
+        });
+    }
+    async removeCategoryFromAllProducts(categoryId) {
+        this.logger = DebugHelper.from(this, 'removeCategoryFromAllProducts');
+        await this.mutation('delete_category_product', ['affected_rows'], {
+            where: {
+                type: 'category_product_bool_exp',
+                required: true,
+                value: { category_id: { _eq: categoryId } },
+            },
+        });
+    }
+}
+
+const fieldsConfiguration$3 = [
+    'id',
     'title',
     'description',
     'slug',
@@ -7163,83 +7654,7 @@ class FilterOptionHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasu
     }
 }
 
-class ProductErrorsHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
-    constructor({ endpoint, authOptions, interceptors, cache, }, productRepository) {
-        super({
-            tableName: 'product_errors',
-            model: ProductErrorsHasuraGraphQL,
-            endpoint,
-            authOptions,
-            interceptors,
-            cache,
-            fields: [
-                {
-                    productId: {
-                        columnName: 'product_id',
-                        to: (value) => +value,
-                        from: (value) => value.toString(),
-                    },
-                },
-                'source',
-                'error',
-                { createdAt: { columnName: 'created_at' } },
-                { updatedAt: { columnName: 'updated_at' } },
-                {
-                    product: {
-                        columnName: 'product',
-                        foreignKeyColumn: { id: 'productId' },
-                        fields: [
-                            { id: { columnName: 'id', from: (value) => value.toString() } },
-                            { productId: { columnName: 'main_product_id' } },
-                            'name',
-                            'published',
-                            'group',
-                            'validity',
-                            { createdAt: { columnName: 'created_at' } },
-                            { updatedAt: { columnName: 'updated_at' } },
-                        ],
-                    },
-                },
-            ],
-        });
-        this.productRepository = productRepository;
-    }
-    async get(params) {
-        const result = await super.get(params);
-        if (result instanceof VariantHasuraGraphQL) {
-            const product = await this.productRepository.get({ id: result.productId.toString() });
-            result.product.name = product.name;
-            result.product.group = product.group;
-        }
-        return result;
-    }
-    async find(params) {
-        const result = await super.find(params);
-        const variantsWithNoData = result.data.filter((item) => item.product instanceof VariantHasuraGraphQL &&
-            (lodash.isEmpty(item.product.name) || lodash.isEmpty(item.product.group) || lodash.isEmpty(item.product)));
-        if (variantsWithNoData.length > 0) {
-            const { data: products } = await this.productRepository.find({
-                filters: {
-                    id: {
-                        operator: exports.Where.IN,
-                        value: Array.from(new Set(variantsWithNoData.map((item) => item.product.productId?.toString()))),
-                    },
-                },
-            });
-            products.forEach((product) => {
-                result.data
-                    .filter((variant) => variant.product.productId?.toString() === product.id.toString())
-                    .forEach((variant) => {
-                    variant.product.name = product.name;
-                    variant.product.group = product.group;
-                });
-            });
-        }
-        return result;
-    }
-}
-
-const commonFields = [
+const commonFields$1 = [
     {
         id: {
             columnName: 'id',
@@ -7319,6 +7734,12 @@ const commonFields = [
             to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
         },
     },
+    {
+        imagesCard: {
+            columnName: 'images_card',
+            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+        },
+    },
     'name',
     {
         price: {
@@ -7380,7 +7801,6 @@ const commonFields = [
     'weight',
     'gender',
     { intGender: { columnName: 'int_gender' } },
-    // { tags: { columnName: 'tags', type: HasuraGraphQLColumnType.Jsonb } },
     { filters: { columnName: 'filters', type: HasuraGraphQLColumnType.Jsonb } },
     { isKit: { columnName: 'is_kit' } },
     { createdAt: { columnName: 'created_at' } },
@@ -7397,187 +7817,746 @@ const commonFields = [
         },
     },
     'group',
+    { groupId: { columnName: 'group_id' } },
     'validity',
     { tagsCollection: { columnName: 'tags_collection', type: HasuraGraphQLColumnType.Jsonb } },
     { tagsProfile: { columnName: 'tags_profile', type: HasuraGraphQLColumnType.Jsonb } },
     { daysOfUse: { columnName: 'days_of_use' } },
+    { showVariants: { columnName: 'show_variants' } },
+    { variantSlug: { columnName: 'variant_slug' } },
 ];
-const fieldsConfiguration$2 = [
-    ...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: [
-                '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' } },
-            ],
-        },
-    },
-    {
-        metadata: {
-            columnName: 'metadata',
-            fields: ['title', 'description'],
-            bindPersistData: (value) => ({
-                metadata: { data: value },
-            }),
-        },
-    },
-    {
-        variants: {
-            columnName: 'variants',
-            foreignKeyColumn: { product_id: 'id' },
-            fields: [
-                'id',
-                'ean',
-                'grade',
-                'price',
-                'published',
-                'stock',
-                { tagsCollection: { columnName: 'tags_collection' } },
-                { tagsProfile: { columnName: 'tags_profile' } },
-            ],
-        },
-    },
-];
-class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
-    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' } },
-        ];
-    }
+class ProductCatalogHasuraGraphQLRepository extends withFindHasuraGraphQL(withHasuraGraphQL(Base)) {
     constructor({ endpoint, authOptions, interceptors, cache, }) {
         super({
-            tableName: 'product',
-            model: ProductHasuraGraphQL,
+            tableName: 'product_catalog',
+            model: ProductCatalogHasuraGraphQL,
             endpoint,
             authOptions,
             interceptors,
-            fields: fieldsConfiguration$2,
+            fields: commonFields$1,
             cache,
         });
-        this.bindReviewToModel = (plain) => ProductReview.toInstance({
-            ...is(lodash.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(lodash.omit(review, ['productId', 'createdAt', 'updatedAt', 'personId', 'orderId'])),
-            person_id: review.personId,
-            order_id: review.orderId,
-        });
-    }
-    async create(params) {
-        const { metadata, ...data } = params;
-        const product = await super.create(lodash.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, options) {
-        const product = Number.isNaN(+identifiers.id)
-            ? (await this.find({ filters: { firestoreId: identifiers.id }, options: { enableCount: false } }, options))
-                .data?.[0]
-            : await super.get(identifiers, options);
-        if (product.productId)
-            throw new NotFoundError('Product not found, it is a variant');
-        product.reviews = product.reviews || (await this.findReviewsByProduct(+product.id, options));
-        return product;
-    }
-    async find(params, optionsParams) {
-        const { filters, fields, ...options } = params || {};
-        const bindFields = fields ||
-            this.fields
-                .map((field) => (typeof field === 'string' ? field : Object.keys(field).shift()))
-                .filter((field) => field !== 'reviews' && field !== 'categories');
-        if (options.options?.minimal?.includes('price'))
-            options.options?.minimal.push('price.price', 'price.fullPrice', 'price.subscriberPrice');
-        if (options.options?.maximum?.includes('price'))
-            options.options?.maximum.push('price.price', 'price.fullPrice', 'price.subscriberPrice');
-        options.options?.minimal?.splice(options.options?.minimal.indexOf('price'), 1);
-        options.options?.maximum?.splice(options.options?.maximum.indexOf('price'), 1);
-        return super.find({
-            ...options,
-            filters: { ...filters, productId: { operator: exports.Where.ISNULL } },
-            fields: [
-                ...bindFields,
-                ...(bindFields.includes('price')
-                    ? [
-                        'subscriberPrice',
-                        'subscriberDiscountPercentage',
-                        'fullPrice',
-                    ]
-                    : []),
-            ],
-        }, optionsParams);
     }
-    async getBySlug(slug, options) {
+    async get({ id }, options) {
         if (this.cache?.cacheAdapter && options?.cache?.enabled) {
-            const cacheKey = `${this.model.name.toLowerCase()}:slug:${slug}`;
+            const cacheKey = `${this.model.name.toLowerCase()}:id:${id}`;
             const cachedData = await this.cache.cacheAdapter.get(cacheKey);
             if (cachedData) {
                 this.logger.log(`Dados recuperados do cache: ${cacheKey}`);
                 return this.model.toInstance(deserialize(cachedData));
             }
         }
-        const result = await this.find({
+        const product = await super
+            .find({
+            filters: {
+                id,
+            },
+            limits: {
+                limit: 1,
+            },
+        })
+            .then((res) => res.data.at(0));
+        if (!product)
+            throw new NotFoundError(`Product not found`);
+        if (this.cache?.cacheAdapter && options?.cache?.enabled && product) {
+            const cacheKey = `${this.model.name.toLowerCase()}:id:${id}`;
+            await this.cache.cacheAdapter.set({
+                key: cacheKey,
+                data: serialize(product),
+                expirationInSeconds: options?.cache?.ttl || this.cache.ttlDefault,
+            });
+            this.logger.log(`Dados salvos no cache: ${cacheKey}`);
+        }
+        return product;
+    }
+    async getByEAN(EAN, options) {
+        if (this.cache?.cacheAdapter && options?.cache?.enabled) {
+            const cacheKey = `${this.model.name.toLowerCase()}:EAN:${EAN}`;
+            const cachedData = await this.cache.cacheAdapter.get(cacheKey);
+            if (cachedData) {
+                this.logger.log(`Dados recuperados do cache: ${cacheKey}`);
+                return this.model.toInstance(deserialize(cachedData));
+            }
+        }
+        const product = await super
+            .find({
+            filters: {
+                EAN,
+            },
+            limits: {
+                limit: 1,
+            },
+        })
+            .then((res) => res.data.at(0));
+        if (!product)
+            return null;
+        RoundProductPricesHelper.roundProductPrices(product);
+        if (this.cache?.cacheAdapter && options?.cache?.enabled && product) {
+            const cacheKey = `${this.model.name.toLowerCase()}:EAN:${EAN}`;
+            await this.cache.cacheAdapter.set({
+                key: cacheKey,
+                data: serialize(product),
+                expirationInSeconds: options?.cache?.ttl || this.cache.ttlDefault,
+            });
+            this.logger.log(`Dados salvos no cache: ${cacheKey}`);
+        }
+        return product;
+    }
+    async find(params, optionsParams) {
+        const { filters, fields, ...options } = params || {};
+        const bindFields = fields ||
+            this.fields
+                .map((field) => (typeof field === 'string' ? field : Object.keys(field).shift()))
+                .filter((field) => field !== 'reviews' && field !== 'categories');
+        if (options.options?.minimal?.includes('price'))
+            options.options?.minimal.push('price.price', 'price.fullPrice', 'price.subscriberPrice');
+        if (options.options?.maximum?.includes('price'))
+            options.options?.maximum.push('price.price', 'price.fullPrice', 'price.subscriberPrice');
+        options.options?.minimal?.splice(options.options?.minimal.indexOf('price'), 1);
+        options.options?.maximum?.splice(options.options?.maximum.indexOf('price'), 1);
+        return super.find({
+            ...options,
+            filters: { ...filters },
+            fields: [
+                ...bindFields,
+                ...(bindFields.includes('price')
+                    ? [
+                        'subscriberPrice',
+                        'subscriberDiscountPercentage',
+                        'fullPrice',
+                    ]
+                    : []),
+            ],
+        }, optionsParams);
+    }
+    async findCatalog(params, mainGender, options) {
+        const result = await this.find({
+            ...params,
+            filters: { ...params.filters, published: true },
+            orderBy: {
+                hasStock: 'desc',
+                ...(!mainGender ? {} : { intGender: mainGender === 'female' ? 'desc' : 'asc' }),
+                ...lodash.omit(params.orderBy, ['hasStock', 'intGender']),
+            },
+        }, options);
+        return result;
+    }
+}
+tslib.__decorate([
+    Log(),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [Object, Object, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ProductCatalogHasuraGraphQLRepository.prototype, "findCatalog", null);
+
+class ProductErrorsHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, cache, }, productRepository) {
+        super({
+            tableName: 'product_errors',
+            model: ProductErrorsHasuraGraphQL,
+            endpoint,
+            authOptions,
+            interceptors,
+            cache,
+            fields: [
+                {
+                    productId: {
+                        columnName: 'product_id',
+                        to: (value) => +value,
+                        from: (value) => value.toString(),
+                    },
+                },
+                'source',
+                'error',
+                { createdAt: { columnName: 'created_at' } },
+                { updatedAt: { columnName: 'updated_at' } },
+                {
+                    product: {
+                        columnName: 'product',
+                        foreignKeyColumn: { id: 'productId' },
+                        fields: [
+                            { id: { columnName: 'id', from: (value) => value.toString() } },
+                            { productId: { columnName: 'main_product_id' } },
+                            'name',
+                            'published',
+                            'group',
+                            'validity',
+                            { createdAt: { columnName: 'created_at' } },
+                            { updatedAt: { columnName: 'updated_at' } },
+                        ],
+                    },
+                },
+            ],
+        });
+        this.productRepository = productRepository;
+    }
+    async get(params) {
+        const result = await super.get(params);
+        if (result instanceof VariantHasuraGraphQL) {
+            const product = await this.productRepository.get({ id: result.productId.toString() });
+            result.product.name = product.name;
+            result.product.group = product.group;
+        }
+        return result;
+    }
+    async find(params) {
+        const result = await super.find(params);
+        const variantsWithNoData = result.data.filter((item) => item.product instanceof VariantHasuraGraphQL &&
+            (lodash.isEmpty(item.product.name) || lodash.isEmpty(item.product.group) || lodash.isEmpty(item.product)));
+        if (variantsWithNoData.length > 0) {
+            const { data: products } = await this.productRepository.find({
+                filters: {
+                    id: {
+                        operator: exports.Where.IN,
+                        value: Array.from(new Set(variantsWithNoData.map((item) => item.product.productId?.toString()))),
+                    },
+                },
+            });
+            products.forEach((product) => {
+                result.data
+                    .filter((variant) => variant.product.productId?.toString() === product.id.toString())
+                    .forEach((variant) => {
+                    variant.product.name = product.name;
+                    variant.product.group = product.group;
+                });
+            });
+        }
+        return result;
+    }
+}
+
+class ProductGroupHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, cache, }) {
+        super({
+            tableName: 'group',
+            model: ProductGroup,
+            endpoint,
+            authOptions,
+            interceptors,
+            fields: [
+                {
+                    id: {
+                        columnName: 'id',
+                        to: (value) => +value,
+                        from: (value) => value.toString(),
+                    },
+                },
+                'name',
+                'description',
+                { markupMin: { columnName: 'markup_min' } },
+                { markupWithoutCompetitor: { columnName: 'markup_without_competitor' } },
+                { discountCompetitor: { columnName: 'discount_competitor' } },
+                { subscriberDiscountPercentage: { columnName: 'subscriber_discount_percentage' } },
+                { dynamicPrecification: { columnName: 'dynamic_precification' } },
+                { createdAt: { columnName: 'created_at' } },
+                { updatedAt: { columnName: 'updated_at' } },
+            ],
+            cache,
+        });
+    }
+}
+
+const commonFields = [
+    {
+        id: {
+            columnName: 'id',
+            to: (value) => +value,
+            from: (value) => value.toString(),
+        },
+    },
+    { firestoreId: { columnName: 'firestore_id' } },
+    { productId: { columnName: 'main_product_id' } },
+    { CEST: { columnName: 'cest' } },
+    { EAN: { columnName: 'ean' } },
+    { NCM: { columnName: 'ncm' } },
+    'brand',
+    { costPrice: { columnName: 'cost_price' } },
+    {
+        description: {
+            columnName: 'description',
+            from: (description, data) => ({
+                description,
+                differentials: data.differentials,
+                whoMustUse: data.who_must_use,
+                howToUse: data.how_to_use,
+                brand: data.brand_description,
+                ingredients: data.ingredients,
+                purpose: data.purpose,
+            }),
+            bindFindFilter: (filters) => {
+                return {
+                    ...(filters?.description && { description: filters.description }),
+                    ...(filters.differentials && { differentials: filters.differentials }),
+                    ...(filters.whoMustUse && {
+                        who_must_use: filters.whoMustUse,
+                    }),
+                    ...(filters.howToUse && {
+                        how_to_use: filters.howToUse,
+                    }),
+                    ...(filters.brand && {
+                        brand_description: filters.brand,
+                    }),
+                    ...(filters.ingredients && {
+                        ingredients: filters.ingredients,
+                    }),
+                    ...(filters.purpose && {
+                        purpose: filters.purpose,
+                    }),
+                };
+            },
+            bindPersistData: (descriptionData) => ({
+                ...(descriptionData?.description && { description: descriptionData.description }),
+                ...(descriptionData.differentials && { differentials: descriptionData.differentials }),
+                ...(descriptionData.whoMustUse && {
+                    who_must_use: descriptionData.whoMustUse,
+                }),
+                ...(descriptionData.howToUse && { how_to_use: descriptionData.howToUse }),
+                ...(descriptionData.brand && { brand_description: descriptionData.brand }),
+                ...(descriptionData.ingredients && { ingredients: descriptionData.ingredients }),
+                ...(descriptionData.purpose && { purpose: descriptionData.purpose }),
+            }),
+        },
+    },
+    { differentials: { columnName: 'differentials' } },
+    { whoMustUse: { columnName: 'who_must_use' } },
+    { howToUse: { columnName: 'how_to_use' } },
+    { brandDescription: { columnName: 'brand_description' } },
+    { ingredients: { columnName: 'ingredients' } },
+    { purpose: { columnName: 'purpose' } },
+    { hasVariants: { columnName: 'has_variants' } },
+    {
+        images: {
+            columnName: 'images',
+            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+        },
+    },
+    {
+        miniatures: {
+            columnName: 'miniatures',
+            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+        },
+    },
+    {
+        imagesCard: {
+            columnName: 'images_card',
+            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+        },
+    },
+    'name',
+    {
+        price: {
+            columnName: 'price',
+            from: (price, data) => ({
+                price,
+                fullPrice: data.full_price,
+                subscriberDiscountPercentage: data.subscriber_discount_percentage,
+                fullPriceDiscountPercentage: data.full_price_discount_percentage,
+                subscriberPrice: data.subscriber_price,
+            }),
+            bindFindFilter: (filters) => {
+                return {
+                    ...((filters?.price || filters?.price === 0) && { price: filters.price }),
+                    ...((filters.fullPrice || filters.fullPrice === 0) && { full_price: filters.fullPrice }),
+                    ...((filters.subscriberDiscountPercentage || filters.subscriberDiscountPercentage === 0) && {
+                        subscriber_discount_percentage: filters.subscriberDiscountPercentage,
+                    }),
+                    ...((filters.subscriberPrice || filters.subscriberPrice === 0) && {
+                        subscriber_price: filters.subscriberPrice,
+                    }),
+                    ...((filters.fullPriceDiscountPercentage || filters.fullPriceDiscountPercentage === 0) && {
+                        full_price_discount_percentage: filters.fullPriceDiscountPercentage,
+                    }),
+                };
+            },
+            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 }),
+                ...(priceData.fullPriceDiscountPercentage >= 0 && {
+                    full_price_discount_percentage: priceData.fullPriceDiscountPercentage,
+                }),
+            }),
+        },
+    },
+    { fullPrice: { columnName: 'full_price' } },
+    { subscriberDiscountPercentage: { columnName: 'subscriber_discount_percentage' } },
+    { fullPriceDiscountPercentage: { columnName: 'full_price_discount_percentage' } },
+    { subscriberPrice: { columnName: 'subscriber_price' } },
+    'published',
+    'outlet',
+    'label',
+    'sku',
+    {
+        stock: {
+            columnName: 'stock',
+            from: (quantity) => ({ quantity }),
+            to: (value) => (lodash.isNil(value?.quantity) ? value : value?.quantity),
+        },
+    },
+    { hasStock: { columnName: 'has_stock' } },
+    'slug',
+    'type',
+    'video',
+    'weight',
+    'gender',
+    { intGender: { columnName: 'int_gender' } },
+    { filters: { columnName: 'filters', type: HasuraGraphQLColumnType.Jsonb } },
+    { isKit: { columnName: 'is_kit' } },
+    { createdAt: { columnName: 'created_at' } },
+    { updatedAt: { columnName: 'updated_at' } },
+    { rate: { columnName: 'rating' } },
+    { reviewsTotal: { columnName: 'reviews_total' } },
+    { shoppingCount: { columnName: 'shopping_count' } },
+    { categoryId: { columnName: 'category_id' } },
+    {
+        category: {
+            columnName: 'category',
+            foreignKeyColumn: { id: 'categoryId' },
+            fields: ['id', 'name', 'reference', 'slug'],
+        },
+    },
+    'group',
+    { groupId: { columnName: 'group_id' } },
+    'validity',
+    { tagsCollection: { columnName: 'tags_collection', type: HasuraGraphQLColumnType.Jsonb } },
+    { tagsProfile: { columnName: 'tags_profile', type: HasuraGraphQLColumnType.Jsonb } },
+    { tagsSupply: { columnName: 'tags_supply', type: HasuraGraphQLColumnType.Jsonb } },
+    { daysOfUse: { columnName: 'days_of_use' } },
+    { showVariants: { columnName: 'show_variants' } },
+    { variantSlug: { columnName: 'variant_slug' } },
+    { caixariaMinima: { columnName: 'caixaria_minima', type: HasuraGraphQLColumnType.Jsonb } },
+    'suppliers',
+    'curve',
+];
+const fieldsConfiguration$2 = [
+    ...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: [
+                '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' } },
+            ],
+        },
+    },
+    {
+        metadata: {
+            columnName: 'metadata',
+            fields: ['title', 'description'],
+            bindPersistData: (value) => ({
+                metadata: { data: value },
+            }),
+        },
+    },
+    {
+        variants: {
+            columnName: 'variants',
+            foreignKeyColumn: { product_id: 'id' },
+            fields: [
+                'id',
+                'name',
+                'ean',
+                'sku',
+                {
+                    description: {
+                        columnName: 'description',
+                        from: (description, data) => ({
+                            description,
+                            differentials: data.differentials,
+                            whoMustUse: data.who_must_use,
+                            howToUse: data.how_to_use,
+                            brand: data.brand_description,
+                            ingredients: data.ingredients,
+                            purpose: data.purpose,
+                        }),
+                        bindFindFilter: (filters) => {
+                            return {
+                                ...(filters?.description && { description: filters.description }),
+                                ...(filters.differentials && { differentials: filters.differentials }),
+                                ...(filters.whoMustUse && {
+                                    who_must_use: filters.whoMustUse,
+                                }),
+                                ...(filters.howToUse && {
+                                    how_to_use: filters.howToUse,
+                                }),
+                                ...(filters.brand && {
+                                    brand_description: filters.brand,
+                                }),
+                                ...(filters.ingredients && {
+                                    ingredients: filters.ingredients,
+                                }),
+                                ...(filters.purpose && {
+                                    purpose: filters.purpose,
+                                }),
+                            };
+                        },
+                        bindPersistData: (descriptionData) => ({
+                            ...(descriptionData?.description && { description: descriptionData.description }),
+                            ...(descriptionData.differentials && { differentials: descriptionData.differentials }),
+                            ...(descriptionData.whoMustUse && {
+                                who_must_use: descriptionData.whoMustUse,
+                            }),
+                            ...(descriptionData.howToUse && { how_to_use: descriptionData.howToUse }),
+                            ...(descriptionData.brand && { brand_description: descriptionData.brand }),
+                            ...(descriptionData.ingredients && { ingredients: descriptionData.ingredients }),
+                            ...(descriptionData.purpose && { purpose: descriptionData.purpose }),
+                        }),
+                    },
+                },
+                { differentials: { columnName: 'differentials' } },
+                { whoMustUse: { columnName: 'who_must_use' } },
+                { howToUse: { columnName: 'how_to_use' } },
+                { brandDescription: { columnName: 'brand_description' } },
+                { ingredients: { columnName: 'ingredients' } },
+                { purpose: { columnName: 'purpose' } },
+                {
+                    grade: {
+                        columnName: 'grade',
+                        type: HasuraGraphQLColumnType.Jsonb,
+                    },
+                },
+                {
+                    price: {
+                        columnName: 'price',
+                        from: (price, data) => ({
+                            price,
+                            fullPrice: data.full_price,
+                            subscriberDiscountPercentage: data.subscriber_discount_percentage,
+                            subscriberPrice: data.subscriber_price,
+                            fullPriceDiscountPercentage: data.full_price_discount_percentage,
+                        }),
+                        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 }),
+                            ...(priceData.fullPriceDiscountPercentage >= 0 && {
+                                full_price_discount_percentage: priceData.fullPriceDiscountPercentage,
+                            }),
+                        }),
+                    },
+                },
+                { fullPrice: { columnName: 'full_price' } },
+                { subscriberDiscountPercentage: { columnName: 'subscriber_discount_percentage' } },
+                { subscriberPrice: { columnName: 'subscriber_price' } },
+                { fullPriceDiscountPercentage: { columnName: 'full_price_discount_percentage' } },
+                'published',
+                {
+                    stock: {
+                        columnName: 'stock',
+                        from: (quantity) => ({ quantity }),
+                        to: (value) => (lodash.isNil(value?.quantity) ? value : value?.quantity),
+                    },
+                },
+                {
+                    images: {
+                        columnName: 'images',
+                        to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+                    },
+                },
+                {
+                    miniatures: {
+                        columnName: 'miniatures',
+                        to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+                    },
+                },
+                {
+                    imagesCard: {
+                        columnName: 'images_card',
+                        to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+                    },
+                },
+                { tagsProfile: { columnName: 'tags_profile' } },
+                { tagsCollection: { columnName: 'tags_collection' } },
+                { variantSlug: { columnName: 'variant_slug' } },
+                {
+                    reviews: {
+                        columnName: 'reviews',
+                        foreignKeyColumn: { product_id: 'id' },
+                        fields: [
+                            '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' } },
+                        ],
+                    },
+                },
+                { filters: { columnName: 'filters', type: HasuraGraphQLColumnType.Jsonb } },
+                {
+                    metadata: {
+                        columnName: 'metadata',
+                        fields: ['title', 'description'],
+                        bindPersistData: (value) => ({
+                            metadata: { data: value },
+                        }),
+                    },
+                },
+            ],
+        },
+    },
+];
+class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    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' } },
+        ];
+    }
+    constructor({ endpoint, authOptions, interceptors, cache, }) {
+        super({
+            tableName: 'product',
+            model: ProductHasuraGraphQL,
+            endpoint,
+            authOptions,
+            interceptors,
+            fields: fieldsConfiguration$2,
+            cache,
+        });
+        this.bindReviewToModel = (plain) => ProductReview.toInstance({
+            ...is(lodash.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(lodash.omit(review, ['productId', 'createdAt', 'updatedAt', 'personId', 'orderId'])),
+            person_id: review.personId,
+            order_id: review.orderId,
+        });
+    }
+    async create(params) {
+        const { metadata, ...data } = params;
+        const product = await super.create(lodash.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, options) {
+        const product = Number.isNaN(+identifiers.id)
+            ? (await this.find({ filters: { firestoreId: identifiers.id }, options: { enableCount: false } }, options))
+                .data?.[0]
+            : await super.get(identifiers, options);
+        if (product.productId)
+            throw new NotFoundError('Product not found, it is a variant');
+        product.reviews = product.reviews || (await this.findReviewsByProduct(+product.id, false, options));
+        if (!product.variants?.length) {
+            for (const [index, variant] of product.variants.entries()) {
+                product.variants[index].reviews = await this.findReviewsByProduct(+variant.id, true);
+            }
+        }
+        return product;
+    }
+    async find(params, optionsParams) {
+        const { filters, fields, ...options } = params || {};
+        const bindFields = fields ||
+            this.fields
+                .map((field) => (typeof field === 'string' ? field : Object.keys(field).shift()))
+                .filter((field) => field !== 'reviews' && field !== 'categories');
+        if (options.options?.minimal?.includes('price'))
+            options.options?.minimal.push('price.price', 'price.fullPrice', 'price.subscriberPrice');
+        if (options.options?.maximum?.includes('price'))
+            options.options?.maximum.push('price.price', 'price.fullPrice', 'price.subscriberPrice');
+        options.options?.minimal?.splice(options.options?.minimal.indexOf('price'), 1);
+        options.options?.maximum?.splice(options.options?.maximum.indexOf('price'), 1);
+        return super.find({
+            ...options,
+            filters: { ...filters, productId: { operator: exports.Where.ISNULL } },
+            fields: [
+                ...bindFields,
+                ...(bindFields.includes('price')
+                    ? [
+                        'subscriberPrice',
+                        'subscriberDiscountPercentage',
+                        'fullPrice',
+                    ]
+                    : []),
+            ],
+        }, optionsParams);
+    }
+    async getBySlug(slug, options) {
+        if (this.cache?.cacheAdapter && options?.cache?.enabled) {
+            const cacheKey = `${this.model.name.toLowerCase()}:slug:${slug}`;
+            const cachedData = await this.cache.cacheAdapter.get(cacheKey);
+            if (cachedData) {
+                this.logger.log(`Dados recuperados do cache: ${cacheKey}`);
+                return this.model.toInstance(deserialize(cachedData));
+            }
+        }
+        const result = await this.find({
             filters: {
                 slug,
+                productId: {
+                    operator: exports.Where.ISNULL,
+                },
             },
             fields: this.fields.map((field) => typeof field === 'string' ? field : Object.keys(field).shift()),
             options: {
@@ -7587,6 +8566,11 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
         if (!result.data.length)
             return null;
         const product = result?.data?.shift();
+        if (!product.variants?.length) {
+            for (const [index, variant] of product.variants.entries()) {
+                product.variants[index].reviews = await this.findReviewsByProduct(+variant.id, true);
+            }
+        }
         RoundProductPricesHelper.roundProductPrices(product);
         if (this.cache?.cacheAdapter && options?.cache?.enabled && product) {
             const cacheKey = `${this.model.name.toLowerCase()}:slug:${slug}`;
@@ -7766,7 +8750,8 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
         const plainData = this.paramsToPlain({ metadata });
         if (!plainData.metadata)
             return null;
-        await this.mutation('update_product_metadata_by_pk', ['product_id'], {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        const { update_product_metadata_by_pk } = await this.mutation('update_product_metadata_by_pk', ['product_id'], {
             pk_columns: {
                 value: { product_id: productId },
                 type: 'product_metadata_pk_columns_input',
@@ -7778,6 +8763,14 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
                 required: true,
             },
         });
+        if (!update_product_metadata_by_pk) {
+            await this.mutation('insert_product_metadata', ['affected_rows'], {
+                objects: {
+                    type: '[product_metadata_insert_input!]!',
+                    value: [{ product_id: productId, ...metadata }],
+                },
+            });
+        }
         return plainData.metadata;
     }
     async getId(id) {
@@ -7788,7 +8781,7 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             return data?.[0]?.id;
         throw new NotFoundError(`Product with id ${id} not found`);
     }
-    async findReviewsByProduct(productId, options) {
+    async findReviewsByProduct(productId, onlyApproved, options) {
         if (this.cache?.cacheAdapter && options?.cache?.enabled) {
             const cacheKey = `${this.model.name.toLowerCase()}:reviews:product:${productId}`;
             const cachedData = await this.cache.cacheAdapter.get(cacheKey);
@@ -7801,10 +8794,16 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             where: {
                 value: {
                     product_id: { _eq: productId },
+                    ...(onlyApproved && { status: { _eq: true } }),
                 },
                 type: 'product_review_bool_exp',
                 required: true,
             },
+            order_by: {
+                type: '[product_review_order_by]',
+                value: [{ createdAt: 'desc' }],
+                required: true,
+            },
         });
         const reviews = data?.map((review) => this.bindReviewToModel(review));
         if (this.cache?.cacheAdapter && options?.cache?.enabled && reviews) {
@@ -7909,10 +8908,53 @@ tslib.__decorate([
 tslib.__decorate([
     Log(),
     tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [Number, Object]),
+    tslib.__metadata("design:paramtypes", [Number, Boolean, Object]),
     tslib.__metadata("design:returntype", Promise)
 ], ProductHasuraGraphQLRepository.prototype, "findReviewsByProduct", null);
 
+class ProductPriceLogHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, cache, }) {
+        super({
+            tableName: 'product_price_log',
+            model: ProductPriceLog,
+            endpoint,
+            authOptions,
+            interceptors,
+            fields: [
+                {
+                    id: {
+                        columnName: 'id',
+                        to: (value) => +value,
+                        from: (value) => value.toString(),
+                    },
+                },
+                { productId: { columnName: 'product_id' } },
+                { productEAN: { columnName: 'product_ean' } },
+                { productSKU: { columnName: 'product_sku' } },
+                { productName: { columnName: 'product_name' } },
+                { productCostPrice: { columnName: 'product_cost_price' } },
+                { productPrice: { columnName: 'product_price' } },
+                { productSubscriberPrice: { columnName: 'product_subscriber_price' } },
+                { productSubscriberDiscountPercentage: { columnName: 'product_subscriber_discount_percentage' } },
+                { markupMin: { columnName: 'markup_min' } },
+                { markupWithoutCompetitor: { columnName: 'markup_without_competitor' } },
+                { discountCompetitor: { columnName: 'discount_competitor' } },
+                { minViablePrice: { columnName: 'min_viable_price' } },
+                { targetPrice: { columnName: 'target_price' } },
+                { groupId: { columnName: 'group_id' } },
+                { competitorsAndPrices: { columnName: 'competitors_and_prices', type: HasuraGraphQLColumnType.Jsonb } },
+                { competitorsPrices: { columnName: 'competitors_prices', type: HasuraGraphQLColumnType.Jsonb } },
+                { competitorsMinPrice: { columnName: 'competitors_min_price' } },
+                { competitorsSellerMinPrice: { columnName: 'competitors_seller_min_price' } },
+                { statusPrecificacao: { columnName: 'status_precificacao' } },
+                { createdAt: { columnName: 'created_at' } },
+                { updatedAt: { columnName: 'updated_at' } },
+            ],
+            cache,
+        });
+    }
+}
+
 class ProductReviewHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
     constructor({ endpoint, authOptions, interceptors, cache, }) {
         super({
@@ -7941,7 +8983,25 @@ class ProductReviewHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHas
                     product: {
                         columnName: 'product',
                         foreignKeyColumn: { id: 'productId' },
-                        fields: ['id', 'ean', 'sku', 'name', 'brand', 'slug', 'images', 'grade', 'gender'],
+                        fields: [
+                            'id',
+                            {
+                                productId: {
+                                    columnName: 'main_product_id',
+                                    to: (value) => +value,
+                                    from: (value) => value?.toString(),
+                                },
+                            },
+                            'ean',
+                            'sku',
+                            'name',
+                            'brand',
+                            'slug',
+                            'images',
+                            'grade',
+                            'gender',
+                            '',
+                        ],
                     },
                 },
             ],
@@ -7986,6 +9046,33 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", void 0)
 ], ProductReviewHasuraGraphQLRepository.prototype, "disaproveReview", null);
 
+class ProductStockEntryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, cache, }) {
+        super({
+            tableName: 'product_millenium_stock_entry',
+            model: ProductStockEntry,
+            endpoint,
+            authOptions,
+            interceptors,
+            cache,
+            fields: [
+                'id',
+                { productId: { columnName: 'product_id' } },
+                { codProduct: { columnName: 'cod_product' } },
+                { productDescription: { columnName: 'product_description' } },
+                { eventDescription: { columnName: 'event_description' } },
+                { invoiceValue: { columnName: 'invoice_value' } },
+                'price',
+                'quantity',
+                { invoiceId: { columnName: 'invoice_id' } },
+                { nfeKey: { columnName: 'nfe_key' } },
+                'batch',
+                { createdAt: { columnName: 'created_at' } },
+            ],
+        });
+    }
+}
+
 class ProductStockNotificationHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
     constructor({ endpoint, authOptions, interceptors, cache, }) {
         super({
@@ -8134,12 +9221,153 @@ const fieldsConfiguration$1 = [
         },
     },
     'group',
+    { groupId: { columnName: 'group_id' } },
+    'type',
     'validity',
-    // { tags: { columnName: 'tags', type: HasuraGraphQLColumnType.Jsonb } },
     'published',
     { tagsCollection: { columnName: 'tags_collection', type: HasuraGraphQLColumnType.Jsonb } },
     { tagsProfile: { columnName: 'tags_profile', type: HasuraGraphQLColumnType.Jsonb } },
+    { tagsSupply: { columnName: 'tags_supply', type: HasuraGraphQLColumnType.Jsonb } },
     { daysOfUse: { columnName: 'days_of_use' } },
+    {
+        images: {
+            columnName: 'images',
+            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+        },
+    },
+    {
+        miniatures: {
+            columnName: 'miniatures',
+            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+        },
+    },
+    {
+        imagesCard: {
+            columnName: 'images_card',
+            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+        },
+    },
+    'slug',
+    'brand',
+    'name',
+    'sku',
+    { NCM: { columnName: 'ncm' } },
+    { CEST: { columnName: 'cest' } },
+    {
+        description: {
+            columnName: 'description',
+            from: (description, data) => ({
+                description,
+                differentials: data.differentials,
+                whoMustUse: data.who_must_use,
+                howToUse: data.how_to_use,
+                brand: data.brand_description,
+                ingredients: data.ingredients,
+                purpose: data.purpose,
+            }),
+            bindFindFilter: (filters) => {
+                return {
+                    ...(filters?.description && { description: filters.description }),
+                    ...(filters.differentials && { differentials: filters.differentials }),
+                    ...(filters.whoMustUse && {
+                        who_must_use: filters.whoMustUse,
+                    }),
+                    ...(filters.howToUse && {
+                        how_to_use: filters.howToUse,
+                    }),
+                    ...(filters.brand && {
+                        brand_description: filters.brand,
+                    }),
+                    ...(filters.ingredients && {
+                        ingredients: filters.ingredients,
+                    }),
+                    ...(filters.purpose && {
+                        purpose: filters.purpose,
+                    }),
+                };
+            },
+            bindPersistData: (descriptionData) => ({
+                ...(descriptionData?.description && { description: descriptionData.description }),
+                ...(descriptionData.differentials && { differentials: descriptionData.differentials }),
+                ...(descriptionData.whoMustUse && {
+                    who_must_use: descriptionData.whoMustUse,
+                }),
+                ...(descriptionData.howToUse && { how_to_use: descriptionData.howToUse }),
+                ...(descriptionData.brand && { brand_description: descriptionData.brand }),
+                ...(descriptionData.ingredients && { ingredients: descriptionData.ingredients }),
+                ...(descriptionData.purpose && { purpose: descriptionData.purpose }),
+            }),
+        },
+    },
+    { differentials: { columnName: 'differentials' } },
+    { whoMustUse: { columnName: 'who_must_use' } },
+    { howToUse: { columnName: 'how_to_use' } },
+    { brandDescription: { columnName: 'brand_description' } },
+    { ingredients: { columnName: 'ingredients' } },
+    { purpose: { columnName: 'purpose' } },
+    'gender',
+    { intGender: { columnName: 'int_gender' } },
+    'label',
+    { filters: { columnName: 'filters', type: HasuraGraphQLColumnType.Jsonb } },
+    { rate: { columnName: 'rating' } },
+    { reviewsTotal: { columnName: 'reviews_total' } },
+    { shoppingCount: { columnName: 'shopping_count' } },
+    { categoryId: { columnName: 'category_id' } },
+    {
+        category: {
+            columnName: 'category',
+            foreignKeyColumn: { id: 'categoryId' },
+            fields: ['id', 'name', 'reference', 'slug'],
+        },
+    },
+    {
+        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()) || [],
+        },
+    },
+    {
+        metadata: {
+            columnName: 'metadata',
+            fields: ['title', 'description'],
+            bindPersistData: (value) => ({
+                metadata: { data: value },
+            }),
+        },
+    },
+    {
+        reviews: {
+            columnName: 'reviews',
+            foreignKeyColumn: { product_id: 'id' },
+            fields: [
+                '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' } },
+            ],
+        },
+    },
+    { variantSlug: { columnName: 'variant_slug' } },
+    { caixariaMinima: { columnName: 'caixaria_minima', type: HasuraGraphQLColumnType.Jsonb } },
+    'suppliers',
+    'curve',
+    { createdAt: { columnName: 'created_at' } },
+    { updatedAt: { columnName: 'updated_at' } },
 ];
 class VariantHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
     constructor({ endpoint, authOptions, interceptors, cache, }) {
@@ -8180,17 +9408,45 @@ class VariantHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
         return data.at(0);
     }
     async update(params) {
-        const { productId, id: checkId, ...data } = params;
+        const { productId, id: checkId, metadata, ...data } = params;
         const dataWithProductId = this.paramsToPlain({ id: checkId, productId });
         if (!dataWithProductId.id) {
             throw new NotFoundError('Variant ID is required for update');
         }
         const id = await this.getId(dataWithProductId.id);
         const product = await super.update({ id, ...data });
+        product.metadata = metadata && (await this.updateMetadata(+id, { metadata }));
         if (dataWithProductId.productId) {
             product.productId = dataWithProductId.productId;
         }
-        return product;
+        return product;
+    }
+    async updateMetadata(productId, { metadata }) {
+        const plainData = this.paramsToPlain({ metadata });
+        if (!plainData.metadata)
+            return null;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        const { update_product_metadata_by_pk } = 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: lodash.omit(metadata, ['product_id']),
+                type: 'product_metadata_set_input',
+                required: true,
+            },
+        });
+        if (!update_product_metadata_by_pk) {
+            await this.mutation('insert_product_metadata', ['affected_rows'], {
+                objects: {
+                    type: '[product_metadata_insert_input!]!',
+                    value: [{ product_id: productId, ...metadata }],
+                },
+            });
+        }
+        return plainData.metadata;
     }
     async getId(id) {
         if (!Number.isNaN(+id))
@@ -8413,124 +9669,670 @@ class WishlistHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
     async getCategoryBySlug(slug, _shop) {
         return this.getWishlistBySlug(slug);
     }
-    async getCategoryByShop(shop) {
-        if (!shop)
-            return;
-        const { data } = await this.find({
-            filters: {
-                shops: { operator: exports.Where.IN, value: [shop] },
-                published: { operator: exports.Where.EQUALS, value: true },
-                isWishlist: { operator: exports.Where.EQUALS, value: true },
-            },
-            options: {
-                enableCount: false,
+    async getCategoryByShop(shop) {
+        if (!shop)
+            return;
+        const { data } = await this.find({
+            filters: {
+                shops: { operator: exports.Where.IN, value: [shop] },
+                published: { operator: exports.Where.EQUALS, value: true },
+                isWishlist: { operator: exports.Where.EQUALS, value: true },
+            },
+            options: {
+                enableCount: false,
+            },
+        });
+        return data;
+    }
+    async findBfluOrGlamgirlWishlists(params, shops) {
+        return this.find({
+            ...params,
+            filters: {
+                ...params.filters,
+                published: true,
+                shops: { operator: exports.Where.LIKE, value: shops },
+                personType: params.filters?.personType ?? {
+                    operator: exports.Where.IN,
+                    value: [exports.PersonTypes.BFLU, exports.PersonTypes.GLAMGIRL],
+                },
+            },
+            orderBy: {
+                personHasPhoto: 'desc',
+                ...lodash.omit(params.orderBy, ['personHasPhoto']),
+            },
+        });
+    }
+    getCategoriesForHome() {
+        return;
+    }
+    mountCategory() {
+        return;
+    }
+    getChildren(_parentId) {
+        return;
+    }
+    isChild(_id, _parentId) {
+        return;
+    }
+    async updateMetadata(categoryId, { metadatas }) {
+        if (Array.isArray(metadatas) && !metadatas.length)
+            return [];
+        if (Array.isArray(metadatas) && metadatas.length) {
+            const metadataUpdated = [];
+            for (const data of metadatas) {
+                const update = await this.mutation('update_category_metadata_by_pk', ['category_id', 'shop'], {
+                    pk_columns: {
+                        value: { category_id: categoryId, shop: data.shop },
+                        type: 'category_metadata_pk_columns_input',
+                        required: true,
+                    },
+                    _set: {
+                        value: lodash.omit(data, ['category_id', 'shop']),
+                        type: 'category_metadata_set_input',
+                        required: true,
+                    },
+                });
+                metadataUpdated.push(update);
+            }
+            return metadataUpdated;
+        }
+        if ('action' in metadatas && metadatas.action === 'remove' && metadatas.value.length) {
+            for (let i = 0; i < metadatas.value.length; i++) {
+                await this.mutation('delete_category_metadata', ['affected_rows'], {
+                    where: {
+                        type: 'category_metadata_bool_exp',
+                        required: true,
+                        value: { category_id: { _eq: categoryId }, shop: metadatas.value[i].shop },
+                    },
+                });
+            }
+            return [];
+        }
+    }
+    async addProduct(wishlistId, productId) {
+        await this.categoryProductRepository.create({
+            categoryId: +wishlistId,
+            productId: +productId,
+            order: 0,
+        });
+    }
+    async removeProduct(wishlistId, productId) {
+        return this.categoryProductRepository.delete({
+            categoryId: +wishlistId,
+            productId: +productId,
+        });
+    }
+    async getBrandsWithProducts() {
+        return;
+    }
+}
+tslib.__decorate([
+    Log(),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [String]),
+    tslib.__metadata("design:returntype", Promise)
+], WishlistHasuraGraphQLRepository.prototype, "getWishlistBySlug", null);
+tslib.__decorate([
+    Log(),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [String]),
+    tslib.__metadata("design:returntype", Promise)
+], WishlistHasuraGraphQLRepository.prototype, "getWishlistByPerson", null);
+tslib.__decorate([
+    Log(),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [String]),
+    tslib.__metadata("design:returntype", Promise)
+], WishlistHasuraGraphQLRepository.prototype, "getCategoryByShop", null);
+tslib.__decorate([
+    Log(),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [Object, Array]),
+    tslib.__metadata("design:returntype", Promise)
+], WishlistHasuraGraphQLRepository.prototype, "findBfluOrGlamgirlWishlists", null);
+
+class MercadoPagoErrorHelper {
+    static getErrorTypeFromResponse(errorCode) {
+        switch (errorCode) {
+            case 'bad_filled_card_data':
+            case 'invalid_card_token':
+            case 'card_disabled':
+            case 'cc_rejected_card_disabled':
+            case 'cc_rejected_bad_filled_card_number':
+            case 'cc_rejected_bad_filled_date':
+            case 'cc_rejected_bad_filled_other':
+            case 'cc_rejected_bad_filled_security_code':
+                return exports.ErrorsCode.invalidCardError;
+            case 'high_risk':
+            case 'rejected_high_risk':
+            case 'cc_rejected_blacklist':
+            case 'cc_rejected_call_for_authorize':
+            case 'cc_rejected_high_risk':
+                return exports.ErrorsCode.fraudPreventionExternal;
+            case 'rejected_by_issuer':
+            case 'rejected_by_bank':
+            case 'cc_rejected_max_attempts':
+            case 'required_call_for_authorize':
+            case 'max_attempts_exceeded':
+                return exports.ErrorsCode.paymentNotAuthorizedError;
+            case 'insufficient_amount':
+            case 'amount_limit_exceeded':
+            case 'cc_rejected_insufficient_amount':
+                return exports.ErrorsCode.insufficientFundsError;
+            case 'processing_error':
+                return exports.ErrorsCode.paymentError;
+            case 'invalid_installments':
+            case 'cc_rejected_invalid_installments':
+            case 'cc_rejected_other_reason':
+            case 'rejected_insufficient_data':
+                return exports.ErrorsCode.businessError;
+            default:
+                return exports.ErrorsCode.paymentError;
+        }
+    }
+}
+
+class MercadoPagoRequestHelper {
+    static build(data) {
+        const { checkout, method, postback, card } = data;
+        return {
+            transaction_amount: +checkout.totalPrice.toFixed(2),
+            notification_url: postback,
+            metadata: {
+                checkoutId: checkout.id,
+            },
+            payer: this.buildPayer(checkout, card),
+            statement_descriptor: checkout.shop === exports.Shops.GLAMSHOP ? 'loja glam' : 'mens market',
+            additional_info: {
+                items: this.buildItems(checkout),
+            },
+            ...(method === 'credit_card' && this.buildCardPayment(card)),
+            ...(method === 'pix' && this.buildPixPayment()),
+            ...(method === 'boleto' && this.buildBoletoPayment(checkout)),
+        };
+    }
+    static buildItems(checkout) {
+        return checkout.lineItems
+            .filter((item) => !item.isGift)
+            .map((item) => {
+            return {
+                id: item.EAN,
+                title: item.name,
+                description: item.name,
+                picture_url: item.image ?? null,
+                category_id: item.category?.id ?? null,
+                quantity: item.quantity,
+                unit_price: +item.pricePaid.toFixed(2),
+            };
+        });
+    }
+    static buildPayer(checkout, card) {
+        return {
+            ...(card && { id: card.customerId }),
+            first_name: checkout.user.firstName,
+            last_name: checkout.user.lastName,
+            email: checkout.user.email,
+            identification: {
+                type: 'CPF',
+                number: checkout.user.cpf.replace(/\D/g, ''),
+            },
+        };
+    }
+    static buildFullPayer(checkout) {
+        return {
+            first_name: checkout.user.firstName,
+            last_name: checkout.user.lastName,
+            phone: {
+                area_code: checkout.user.phone.substring(0, 2),
+                number: checkout.user.phone.substring(2),
+            },
+            address: {
+                zip_code: checkout.shippingAddress.zip,
+                street_name: `${checkout.shippingAddress.street}, ${checkout.shippingAddress.district}`,
+                street_number: checkout.shippingAddress.number,
+                neighborhood: checkout.shippingAddress.district,
+                city: checkout.shippingAddress.city,
+                federal_unit: checkout.shippingAddress.state,
+            },
+        };
+    }
+    static buildCardPayment(card) {
+        return {
+            installments: card.installments,
+            token: card.cardId,
+            binary_mode: true,
+            capture: true,
+        };
+    }
+    static buildPixPayment() {
+        return {
+            payment_method_id: 'pix',
+            date_of_expiration: dateFns.format(dateFns.addHours(new Date(), 24), "yyyy-MM-dd'T'HH:mm:ss.SSSxxx"),
+        };
+    }
+    static buildBoletoPayment(checkout) {
+        return {
+            payment_method_id: 'bolbradesco',
+            date_of_expiration: dateFns.format(dateFns.addDays(new Date(), 3), 'yyyy-MM-dd') + 'T23:59:59.999-03:00',
+            payer: {
+                first_name: checkout.user.firstName,
+                last_name: checkout.user.lastName,
+                email: checkout.user.email,
+                identification: {
+                    type: 'CPF',
+                    number: checkout.user.cpf.replace(/\D/g, ''),
+                },
+                phone: {
+                    area_code: checkout.user.phone.substring(0, 2),
+                    number: checkout.user.phone.substring(2),
+                },
+                address: {
+                    zip_code: checkout.shippingAddress.zip.replace(/\D/g, ''),
+                    street_name: `${checkout.shippingAddress.street}, ${checkout.shippingAddress.district}`,
+                    street_number: checkout.shippingAddress.number,
+                    neighborhood: checkout.shippingAddress.district,
+                    city: checkout.shippingAddress.city,
+                    federal_unit: checkout.shippingAddress.state,
+                },
+            },
+        };
+    }
+}
+
+class MercadoPagoResponseHelper {
+    static build(method, checkout, response) {
+        return Payment.toInstance({
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            userId: checkout.user.id,
+            checkoutId: checkout.id,
+            totalPrice: checkout.totalPrice,
+            paymentProvider: exports.PaymentProviders.MERCADOPAGO,
+            mercadoPagoId: response.id,
+            transaction: this.buildPaymentTransaction(method, response),
+        });
+    }
+    static buildPaymentTransaction(method, response) {
+        return PaymentTransaction.toInstance({
+            id: response.id.toString(),
+            acquirer_name: exports.PaymentProviders.MERCADOPAGO,
+            amount: response.transaction_amount,
+            status: this.statusMapping(response.status),
+            status_reason: response.status_detail?.toString(),
+            payment_method: method,
+            currency: response.currency_id?.toString(),
+            paid_amount: response.transaction_details?.total_paid_amount ?? null,
+            paid_at: response.date_approved ?? null,
+            charger_id: response.charges_details?.at(0)?.id?.toString() ?? null,
+            ...(method == exports.TransactionPaymentMethods.PIX && this.getPixReponse(response)),
+            ...(method == exports.TransactionPaymentMethods.CARD && this.getCardReponse(response)),
+            ...(method == exports.TransactionPaymentMethods.BANKSLIP && this.getBoletoReponse(response)),
+        });
+    }
+    static getBoletoReponse(response) {
+        return {
+            boleto_url: response.transaction_details?.external_resource_url?.toString(),
+            boleto_barcode: response.transaction_details?.barcode?.content?.toString(),
+            boleto_line: response.transaction_details?.digitable_line?.toString(),
+            boleto_expiration_date: response.date_of_expiration?.toString(),
+            boleto_document_number: response.transaction_details?.verification_code?.toString(),
+        };
+    }
+    static getPixReponse(response) {
+        return {
+            pix_qr_code: response.point_of_interaction?.transaction_data?.qr_code,
+            pix_expiration_date: response.date_of_expiration?.toString(),
+        };
+    }
+    static getCardReponse(response) {
+        return {
+            soft_descriptor: response.statement_descriptor?.toString(),
+            installments: response.installments,
+            card_brand: response.payment_method_id?.toString(),
+            card_first_digits: response.card?.first_six_digits?.toString(),
+            card_last_digits: response.card?.last_four_digits?.toString(),
+            card_id: response.card?.id?.toString(),
+            card_holder_name: response.card?.cardholder?.name?.toString(),
+            card_expiration_month: response.card?.expiration_month?.toString(),
+            card_expiration_year: response.card?.expiration_year?.toString(),
+            capture_method: response.payment_type_id?.toString(),
+            authorization_code: response.authorization_code?.toString(),
+            paid_amount: this.statusMapping(response.status) == 'paid' ? response.transaction_details?.total_paid_amount : null,
+            paid_at: this.statusMapping(response.status) == 'paid' ? response.date_approved : null,
+        };
+    }
+    static statusMapping(status) {
+        const statusMap = {
+            approved: 'paid',
+            pending: 'waiting_payment',
+            in_process: 'processing',
+            rejected: 'refused',
+            cancelled: 'refused',
+            refunded: 'refunded',
+            charged_back: 'chargedback',
+        };
+        return statusMap[status] || status;
+    }
+}
+
+class MercadoPagoBankSlipAxiosAdapter {
+    constructor(credentials, paymentRepository) {
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+    }
+    async pay(checkout) {
+        try {
+            const payload = MercadoPagoRequestHelper.build({
+                checkout,
+                method: 'boleto',
+                postback: this.credentials.postback,
+            });
+            console.warn('[MERCADO PAGO BOLETO DATA TO SEND]', JSON.stringify(payload));
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.url}/v1/payments`,
+                headers: {
+                    'X-Idempotency-Key': `${checkout.id}-${new Date().getTime()}`,
+                    Authorization: `Bearer ${this.credentials.api_key}`,
+                    'Content-Type': 'application/json',
+                },
+                data: payload,
+            });
+            console.warn('[MERCADO PAGO RESPONSE BOLETO DATA]', JSON.stringify(data));
+            const payment = await this.paymentRepository.create(MercadoPagoResponseHelper.build(exports.TransactionPaymentMethods.BANKSLIP, checkout, data));
+            return payment;
+        }
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.warn(JSON.stringify(error.response.data.message));
+            }
+            throw new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', exports.ErrorsCode.paymentError, {
+                checkoutId: checkout.id,
+                userEmail: checkout.user.email,
+                info: error.response.data?.message || error.message?.toString(),
+            });
+        }
+    }
+    getBoletoTransaction(paymentId) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+exports.MercadoPagoStatusDetailEnum = void 0;
+(function (MercadoPagoStatusDetailEnum) {
+    MercadoPagoStatusDetailEnum["accredited"] = "accredited";
+    MercadoPagoStatusDetailEnum["partially_refunded"] = "partially_refunded";
+    MercadoPagoStatusDetailEnum["pending_capture"] = "pending_capture";
+    MercadoPagoStatusDetailEnum["offline_process"] = "offline_process";
+    MercadoPagoStatusDetailEnum["pending_contingency"] = "pending_contingency";
+    MercadoPagoStatusDetailEnum["pending_review_manual"] = "pending_review_manual";
+    MercadoPagoStatusDetailEnum["pending_waiting_transfer"] = "pending_waiting_transfer";
+    MercadoPagoStatusDetailEnum["pending_waiting_payment"] = "pending_waiting_payment";
+    MercadoPagoStatusDetailEnum["pending_challenge"] = "pending_challenge";
+    MercadoPagoStatusDetailEnum["bank_error"] = "bank_error";
+    MercadoPagoStatusDetailEnum["cc_rejected_3ds_mandatory"] = "cc_rejected_3ds_mandatory";
+    MercadoPagoStatusDetailEnum["cc_rejected_bad_filled_card_number"] = "cc_rejected_bad_filled_card_number";
+    MercadoPagoStatusDetailEnum["cc_rejected_bad_filled_date"] = "cc_rejected_bad_filled_date";
+    MercadoPagoStatusDetailEnum["cc_rejected_bad_filled_other"] = "cc_rejected_bad_filled_other";
+    MercadoPagoStatusDetailEnum["cc_rejected_bad_filled_security_code"] = "cc_rejected_bad_filled_security_code";
+    MercadoPagoStatusDetailEnum["cc_rejected_blacklist"] = "cc_rejected_blacklist";
+    MercadoPagoStatusDetailEnum["cc_rejected_call_for_authorize"] = "cc_rejected_call_for_authorize";
+    MercadoPagoStatusDetailEnum["cc_rejected_card_disabled"] = "cc_rejected_card_disabled";
+    MercadoPagoStatusDetailEnum["cc_rejected_card_error"] = "cc_rejected_card_error";
+    MercadoPagoStatusDetailEnum["cc_rejected_duplicated_payment"] = "cc_rejected_duplicated_payment";
+    MercadoPagoStatusDetailEnum["cc_rejected_high_risk"] = "cc_rejected_high_risk";
+    MercadoPagoStatusDetailEnum["cc_rejected_insufficient_amount"] = "cc_rejected_insufficient_amount";
+    MercadoPagoStatusDetailEnum["cc_rejected_invalid_installments"] = "cc_rejected_invalid_installments";
+    MercadoPagoStatusDetailEnum["cc_rejected_max_attempts"] = "cc_rejected_max_attempts";
+    MercadoPagoStatusDetailEnum["cc_rejected_other_reason"] = "cc_rejected_other_reason";
+    MercadoPagoStatusDetailEnum["cc_amount_rate_limit_exceeded"] = "cc_amount_rate_limit_exceeded";
+    MercadoPagoStatusDetailEnum["rejected_insufficient_data"] = "rejected_insufficient_data";
+    MercadoPagoStatusDetailEnum["rejected_by_bank"] = "rejected_by_bank";
+    MercadoPagoStatusDetailEnum["rejected_by_regulations"] = "rejected_by_regulations";
+    MercadoPagoStatusDetailEnum["insufficient_amount"] = "insufficient_amount";
+    MercadoPagoStatusDetailEnum["cc_rejected_card_type_not_allowed"] = "cc_rejected_card_type_not_allowed";
+})(exports.MercadoPagoStatusDetailEnum || (exports.MercadoPagoStatusDetailEnum = {}));
+
+exports.MercadoPagoStatusEnum = void 0;
+(function (MercadoPagoStatusEnum) {
+    MercadoPagoStatusEnum["approved"] = "approved";
+    MercadoPagoStatusEnum["authorized"] = "authorized";
+    MercadoPagoStatusEnum["pending"] = "pending";
+    MercadoPagoStatusEnum["in_process"] = "in_process";
+    MercadoPagoStatusEnum["rejected"] = "rejected";
+    MercadoPagoStatusEnum["cancelled"] = "cancelled";
+    MercadoPagoStatusEnum["refunded"] = "refunded";
+    MercadoPagoStatusEnum["charged_back"] = "charged_back";
+})(exports.MercadoPagoStatusEnum || (exports.MercadoPagoStatusEnum = {}));
+
+class MercadoPagoBaseAxiosAdapter {
+    constructor(credentials, paymentRepository) {
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+    }
+    async refund(order, amount) {
+        const { data } = await axios__default["default"]({
+            method: 'POST',
+            url: `${this.credentials.url}/v1/payments/${order.payment.id}/refunds`,
+            headers: {
+                'X-Idempotency-Key': `${order.payment.charger_id}-${new Date().getTime()}`,
+                Authorization: `Bearer ${this.credentials.api_key}`,
+                'Content-Type': 'application/json',
+            },
+            data: {
+                amount: +amount.toFixed(2),
+            },
+        });
+        await this.paymentRepository.create({
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            userId: order.user.id,
+            orderId: order.id,
+            totalPrice: amount,
+            paymentProvider: exports.PaymentProviders.MERCADOPAGO,
+            mercadoPagoId: data.id,
+            transaction: data,
+        });
+        console.warn('[RESPONSE MERCADO PAGO REFUND]', JSON.stringify(data));
+        return {
+            status: this.getRefundStatus(data.status),
+            success: [
+                exports.MercadoPagoStatusEnum.approved,
+                exports.MercadoPagoStatusEnum.refunded,
+                exports.MercadoPagoStatusEnum.cancelled,
+                exports.MercadoPagoStatusEnum.authorized,
+            ].includes(data.status)
+                ? true
+                : false,
+        };
+    }
+    getRefundStatus(status) {
+        if ([exports.MercadoPagoStatusEnum.in_process, exports.MercadoPagoStatusEnum.pending].includes(status)) {
+            return 'processing';
+        }
+        if ([
+            exports.MercadoPagoStatusEnum.approved,
+            exports.MercadoPagoStatusEnum.refunded,
+            exports.MercadoPagoStatusEnum.cancelled,
+            exports.MercadoPagoStatusEnum.authorized,
+        ].includes(status)) {
+            return 'success';
+        }
+        return 'unknown';
+    }
+}
+
+class MercadoPagoCardAxiosAdapter extends MercadoPagoBaseAxiosAdapter {
+    constructor(credentials, paymentRepository, orderBlockedRepository) {
+        super(credentials, paymentRepository);
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+        this.orderBlockedRepository = orderBlockedRepository;
+    }
+    async pay(checkout, card) {
+        try {
+            const payload = await this.getPaymentPayload(checkout, card);
+            console.warn('[MERCADO PAGO CARD DATA TO SEND]', JSON.stringify(payload));
+            const data = await this.requestPayment(checkout, payload);
+            console.warn('[MERCADO PAGO RESPONSE CARD DATA]', JSON.stringify(data));
+            if (data.status == exports.MercadoPagoStatusEnum.rejected) {
+                await this.orderBlockedRepository.createBlockedOrderOrPayment({
+                    checkout,
+                    blockType: 'Card not authorized',
+                    type: 'Card',
+                    limiteRange: 'day',
+                    card,
+                    gatewayInfo: {
+                        gateway: exports.PaymentProviders.MERCADOPAGO,
+                        status: data.status,
+                        statusDetail: data.status_detail,
+                    },
+                });
+                const errorCode = MercadoPagoErrorHelper.getErrorTypeFromResponse(data.status_detail);
+                throw new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', errorCode, {
+                    checkoutId: checkout.id,
+                    userEmail: checkout.user.email,
+                    info: data,
+                });
+            }
+            const payment = await this.paymentRepository.create(MercadoPagoResponseHelper.build(exports.TransactionPaymentMethods.CARD, checkout, data));
+            return payment;
+        }
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.warn(JSON.stringify(error.response?.data?.message));
+                throw new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', exports.ErrorsCode.paymentError, {
+                    checkoutId: checkout.id,
+                    userEmail: checkout.user.email,
+                    info: error.response?.data?.message || error.message?.toString(),
+                });
+            }
+            throw error;
+        }
+    }
+    async requestPayment(checkout, payload) {
+        const { data } = await axios__default["default"]({
+            method: 'POST',
+            url: `${this.credentials.url}/v1/payments`,
+            headers: {
+                'X-Idempotency-Key': `${checkout.id}-${new Date().getTime()}`,
+                Authorization: `Bearer ${this.credentials.api_key}`,
+                'Content-Type': 'application/json',
             },
+            data: payload,
         });
         return data;
     }
-    async findBfluOrGlamgirlWishlists(params, shops) {
-        return this.find({
-            ...params,
-            filters: {
-                ...params.filters,
-                published: true,
-                shops: { operator: exports.Where.LIKE, value: shops },
-                personType: params.filters?.personType ?? {
-                    operator: exports.Where.IN,
-                    value: [exports.PersonTypes.BFLU, exports.PersonTypes.GLAMGIRL],
-                },
-            },
-            orderBy: {
-                personHasPhoto: 'desc',
-                ...lodash.omit(params.orderBy, ['personHasPhoto']),
+    async getPaymentPayload(checkout, card) {
+        const cardResponse = await this.getCardByToken(card.customerId, card.cardId, card.cardCvv);
+        const payload = MercadoPagoRequestHelper.build({
+            checkout,
+            method: 'credit_card',
+            postback: this.credentials.postback,
+            card: {
+                ...card,
+                cardId: cardResponse.id,
             },
         });
+        return payload;
     }
-    getCategoriesForHome() {
+    async addCard(card, customer) {
         return;
     }
-    mountCategory() {
-        return;
+    async getCardByToken(customerId, token, cardCvv) {
+        try {
+            const payload = { cardId: token, customerId: customerId, securityCode: cardCvv };
+            console.warn('payload getCardByToken', payload);
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.url}/v1/card_tokens`,
+                headers: {
+                    Authorization: `Bearer ${this.credentials.api_key}`,
+                    'Content-Type': 'application/json',
+                },
+                data: payload,
+            });
+            return data;
+        }
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.warn(JSON.stringify(error.response.data.cause));
+            }
+            throw error;
+        }
     }
-    getChildren(_parentId) {
+    createCardHash(bu, shop, card) {
         return;
     }
-    isChild(_id, _parentId) {
+    createTransaction(info) {
         return;
     }
-    async updateMetadata(categoryId, { metadatas }) {
-        if (Array.isArray(metadatas) && !metadatas.length)
-            return [];
-        if (Array.isArray(metadatas) && metadatas.length) {
-            const metadataUpdated = [];
-            for (const data of metadatas) {
-                const update = await this.mutation('update_category_metadata_by_pk', ['category_id', 'shop'], {
-                    pk_columns: {
-                        value: { category_id: categoryId, shop: data.shop },
-                        type: 'category_metadata_pk_columns_input',
-                        required: true,
-                    },
-                    _set: {
-                        value: lodash.omit(data, ['category_id', 'shop']),
-                        type: 'category_metadata_set_input',
-                        required: true,
-                    },
-                });
-                metadataUpdated.push(update);
-            }
-            return metadataUpdated;
+    async createOrUpdateCustomer(customer) {
+        const { data } = await axios__default["default"]({
+            method: 'POST',
+            url: `${this.credentials.url}/v1/customers`,
+            headers: {
+                Authorization: `Bearer ${this.credentials.api_key}`,
+                'Content-Type': 'application/json',
+            },
+            data: {
+                email: customer.email,
+                first_name: customer.firstName,
+                last_name: customer.lastName,
+                phone: {
+                    area_code: customer.phone.substring(0, 2),
+                    number: customer.phone.substring(2),
+                },
+                identification: {
+                    type: 'CPF',
+                    number: customer.cpf.replace(/\D/g, ''),
+                },
+            },
+        });
+        return data;
+    }
+}
+
+class MercadoPagoPixAxiosAdapter extends MercadoPagoBaseAxiosAdapter {
+    constructor(credentials, paymentRepository) {
+        super(credentials, paymentRepository);
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+    }
+    async pay(checkout) {
+        try {
+            const payload = MercadoPagoRequestHelper.build({
+                checkout,
+                method: 'pix',
+                postback: this.credentials.postback,
+            });
+            console.warn('[MERCADO PAGO PIX DATA TO SEND]', JSON.stringify(payload));
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.url}/v1/payments`,
+                headers: {
+                    'X-Idempotency-Key': `${checkout.id}-${new Date().getTime()}`,
+                    Authorization: `Bearer ${this.credentials.api_key}`,
+                    'Content-Type': 'application/json',
+                },
+                data: payload,
+            });
+            console.warn('[MERCADO PAGO RESPONSE PIX DATA]', JSON.stringify(data));
+            const payment = await this.paymentRepository.create(MercadoPagoResponseHelper.build(exports.TransactionPaymentMethods.PIX, checkout, data));
+            return payment;
         }
-        if ('action' in metadatas && metadatas.action === 'remove' && metadatas.value.length) {
-            for (let i = 0; i < metadatas.value.length; i++) {
-                await this.mutation('delete_category_metadata', ['affected_rows'], {
-                    where: {
-                        type: 'category_metadata_bool_exp',
-                        required: true,
-                        value: { category_id: { _eq: categoryId }, shop: metadatas.value[i].shop },
-                    },
-                });
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.warn(JSON.stringify(error.response.data.message));
             }
-            return [];
+            throw new PaymentError('Houve uma falha ao processar pagamento com pix', exports.ErrorsCode.paymentError, {
+                checkoutId: checkout.id,
+                userEmail: checkout.user.email,
+                info: error.response.data?.message || error.message?.toString(),
+            });
         }
     }
-    async addProduct(wishlistId, productId) {
-        await this.categoryProductRepository.create({
-            categoryId: +wishlistId,
-            productId: +productId,
-            order: 0,
-        });
-    }
-    async removeProduct(wishlistId, productId) {
-        return this.categoryProductRepository.delete({
-            categoryId: +wishlistId,
-            productId: +productId,
-        });
-    }
 }
-tslib.__decorate([
-    Log(),
-    tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [String]),
-    tslib.__metadata("design:returntype", Promise)
-], WishlistHasuraGraphQLRepository.prototype, "getWishlistBySlug", null);
-tslib.__decorate([
-    Log(),
-    tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [String]),
-    tslib.__metadata("design:returntype", Promise)
-], WishlistHasuraGraphQLRepository.prototype, "getWishlistByPerson", null);
-tslib.__decorate([
-    Log(),
-    tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [String]),
-    tslib.__metadata("design:returntype", Promise)
-], WishlistHasuraGraphQLRepository.prototype, "getCategoryByShop", null);
-tslib.__decorate([
-    Log(),
-    tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [Object, Array]),
-    tslib.__metadata("design:returntype", Promise)
-], WishlistHasuraGraphQLRepository.prototype, "findBfluOrGlamgirlWishlists", null);
 
 class PagarmeBankSlipAxiosAdapter {
     constructor(credentials, paymentRepository) {
@@ -8547,7 +10349,7 @@ class PagarmeBankSlipAxiosAdapter {
             });
             console.warn('[PAGARME BOLETO DATA TO SEND]', payload);
             if (result.data.status !== exports.PagarmePaymentStatus['Em processamento']) {
-                return Promise.reject(new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', {
+                return Promise.reject(new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', exports.ErrorsCode.paymentError, {
                     checkoutId: checkout.id,
                     userEmail: checkout.user.email,
                     info: result.data,
@@ -8565,7 +10367,7 @@ class PagarmeBankSlipAxiosAdapter {
             return payment;
         }
         catch (error) {
-            throw new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', {
+            throw new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', exports.ErrorsCode.paymentError, {
                 checkoutId: checkout.id,
                 userEmail: checkout.user.email,
                 info: error.response.data,
@@ -8613,62 +10415,423 @@ class PagarmeBankSlipAxiosAdapter {
             },
         };
     }
-}
-
-class PagarmeBlockedOrderHelper {
-    static async createBlockedOrderForUnauthorizedCard(params) {
-        const { checkout, card, orderBlockedRepository } = params;
-        await orderBlockedRepository.createBlockedOrderOrPayment({
-            checkout,
-            blockType: 'Card not authorized',
-            type: 'Card',
-            limiteRange: 'day',
-            card,
-        });
-    }
-    static createPaymentError(checkout, resultData) {
-        return new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', {
-            checkoutId: checkout.id,
-            userEmail: checkout.user.email,
-            info: resultData,
-        });
-    }
-    static createGenericPaymentError(checkout, errorResponseData) {
-        return new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', {
-            checkoutId: checkout.id,
-            userEmail: checkout.user.email,
-            info: errorResponseData,
-        });
+}
+
+class PagarmeBlockedOrderHelper {
+    static async createBlockedOrderForUnauthorizedCard(params) {
+        const { checkout, card, orderBlockedRepository, gatewayInfo } = params;
+        await orderBlockedRepository.createBlockedOrderOrPayment({
+            checkout,
+            blockType: 'Card not authorized',
+            type: 'Card',
+            limiteRange: 'day',
+            card,
+            gatewayInfo,
+        });
+    }
+    static createPaymentError(checkout, errorType, resultData) {
+        return new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', errorType, {
+            checkoutId: checkout.id,
+            userEmail: checkout.user.email,
+            info: resultData,
+        });
+    }
+    static createGenericPaymentError(checkout, errorType, errorResponseData) {
+        return new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', errorType, {
+            checkoutId: checkout.id,
+            userEmail: checkout.user.email,
+            info: errorResponseData,
+        });
+    }
+}
+
+/* eslint-disable complexity */
+class PagarMeErrorHelper {
+    static getErrorTypeFromResponse(errorCode) {
+        switch (errorCode) {
+            // Cartão inválido, vencido, bloqueado
+            case '1000':
+            case '1001':
+            case '1011':
+            case '1025':
+            case '1032':
+            case '1045':
+            case '1068':
+            case '1069':
+            case '1070':
+            case '2001':
+            case '2004':
+            case '5025':
+            case '9124':
+                return exports.ErrorsCode.invalidCardError;
+            // Dados obrigatórios ausentes
+            case '1044':
+            case '5034':
+            case '5047':
+            case '5061':
+                return exports.ErrorsCode.invalidCardError;
+            // Suspeita de fraude, prevenção do banco
+            case '1002':
+            case '1004':
+            case '1019':
+            case '2002':
+            case '2005':
+            case '2007':
+            case '2008':
+            case '2009':
+            case '2010':
+            case '9201':
+                return exports.ErrorsCode.fraudPreventionExternal;
+            // Recusado pelo banco/emissor
+            case '1007':
+            case '1008':
+            case '2000':
+            case '5093':
+                return exports.ErrorsCode.paymentNotAuthorizedError;
+            // Saldo/limite insuficiente ou excedido
+            case '1016':
+            case '1021':
+            case '1023':
+            case '2011':
+            case '2012':
+            case '5051':
+            case '5087':
+                return exports.ErrorsCode.insufficientFundsError;
+            // Valor solicitado inválido
+            case '5094':
+            case '5016':
+            case '5092':
+                return exports.ErrorsCode.paymentError;
+            // Erros internos ou genéricos
+            case '5000':
+            case '5001':
+            case '5003':
+            case '5004':
+            case '5006':
+            case '5008':
+            case '5009':
+            case '5010':
+            case '5011':
+            case '5012':
+            case '5013':
+            case '5014':
+            case '5015':
+            case '5017':
+            case '5018':
+            case '5019':
+            case '5020':
+            case '5021':
+            case '5022':
+            case '5023':
+            case '5024':
+            case '5026':
+            case '5027':
+            case '5028':
+            case '5029':
+            case '5030':
+            case '5031':
+            case '5032':
+            case '5033':
+            case '5035':
+            case '5036':
+            case '5037':
+            case '5038':
+            case '5039':
+            case '5040':
+            case '5041':
+            case '5042':
+            case '5043':
+            case '5044':
+            case '5045':
+            case '5049':
+            case '5050':
+            case '5052':
+            case '5053':
+            case '5054':
+            case '5055':
+            case '5056':
+            case '5057':
+            case '5058':
+            case '5059':
+            case '5060':
+            case '5062':
+            case '5063':
+            case '5064':
+            case '5065':
+            case '5066':
+            case '5067':
+            case '5068':
+            case '5069':
+            case '5070':
+            case '5071':
+            case '5072':
+            case '5073':
+            case '5074':
+            case '5075':
+            case '5076':
+            case '5077':
+            case '5078':
+            case '5079':
+            case '5080':
+            case '5081':
+            case '5082':
+            case '5083':
+            case '5084':
+            case '5085':
+            case '5089':
+            case '5090':
+            case '5095':
+            case '5096':
+            case '5097':
+                return exports.ErrorsCode.paymentError;
+            // Banco/emissor inválido ou não operante
+            case '1049':
+            case '1050':
+                return exports.ErrorsCode.paymentError;
+            // Transação não suportada para o banco/emissor
+            case '1061':
+                return exports.ErrorsCode.paymentError;
+            case '1010':
+            case '1046':
+                return exports.ErrorsCode.invalidCheckoutError;
+            default:
+                return exports.ErrorsCode.paymentError;
+        }
+    }
+}
+
+class PagarmePaymentFactoryHelper {
+    static async createSuccessfulPayment(params) {
+        const { checkout, resultData, paymentRepository } = params;
+        const payment = await paymentRepository.create({
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            userId: checkout.user.id,
+            checkoutId: checkout.id,
+            totalPrice: checkout.totalPrice,
+            paymentProvider: exports.PaymentProviders.PAGARME,
+            transaction: { ...resultData, paidAt: new Date() },
+        });
+        return payment;
+    }
+}
+
+class PagarmePaymentOperationsHelper {
+    static async executePaymentRequest(params) {
+        const { checkout, card, credentials, createPayloadFunction } = params;
+        const payload = createPayloadFunction(checkout, card);
+        console.warn('[PAGARME CARD DATA TO SEND]', payload);
+        const result = await axios__default["default"]({
+            method: 'POST',
+            url: `${credentials.URL}/transactions`,
+            data: payload,
+        });
+        return result;
+    }
+}
+
+class PagarMeV5RequestHelper {
+    static build(checkout, method, card) {
+        return {
+            items: this.buildItems(checkout),
+            customer: this.buildCustomer(checkout),
+            shipping: this.buildShipping(checkout),
+            payments: this.buildPayment(checkout, method, card),
+            ...this.buildAdditionalInfo(checkout),
+        };
+    }
+    static buildItems(checkout) {
+        const isSubscriber = checkout.user?.isSubscriber ?? false;
+        return checkout.lineItems
+            .filter((item) => !item.isGift)
+            .map((item) => {
+            return {
+                amount: Math.floor(item.pricePaid * 100),
+                description: isSubscriber ? `${item.name} - ASSINANTE` : item.name,
+                quantity: item.quantity,
+                code: item.EAN,
+            };
+        });
+    }
+    static buildCustomer(checkout) {
+        return {
+            name: checkout.user.displayName,
+            email: checkout.user.email,
+            type: 'individual',
+            document: checkout.user.cpf,
+            phones: {
+                home_phone: {
+                    country_code: '55',
+                    number: checkout.user.phone.slice(2),
+                    area_code: checkout.user.phone.slice(0, 2),
+                },
+                mobile_phone: {
+                    country_code: '55',
+                    number: checkout.user.phone.slice(2),
+                    area_code: checkout.user.phone.slice(0, 2),
+                },
+            },
+            address: {
+                line_1: `${checkout.billingAddress.number}, ${checkout.billingAddress.street}, ${checkout.billingAddress.district}`,
+                line_2: `${checkout.billingAddress.extension}`,
+                zip_code: checkout.shippingAddress.zip,
+                city: checkout.billingAddress.city,
+                state: checkout.billingAddress.state,
+                country: 'BR',
+            },
+        };
+    }
+    static buildShipping(checkout) {
+        return {
+            amount: Math.floor(checkout.shipping.ShippingPrice * 100),
+            description: `${checkout.shipping.ShippingCompanyName} - ${checkout.shipping.description}`,
+            recipient_name: checkout.shippingAddress.recipient,
+            recipient_phone: checkout.user.phone,
+            address: {
+                line_1: `${checkout.shippingAddress.number}, ${checkout.shippingAddress.street}, ${checkout.shippingAddress.district}`,
+                line_2: `${checkout.shippingAddress.extension}`,
+                zip_code: checkout.shippingAddress.zip,
+                city: checkout.shippingAddress.city,
+                state: checkout.shippingAddress.state,
+                country: 'BR',
+            },
+        };
+    }
+    static buildPayment(checkout, method, card) {
+        return [
+            {
+                payment_method: method,
+                amount: Math.floor(checkout.totalPrice * 100),
+                ...(method === 'pix' && {
+                    pix: this.getPixOrder(),
+                }),
+                ...(method === 'boleto' && {
+                    boleto: this.getBoletoOrder(),
+                }),
+                ...(method === 'credit_card' && {
+                    credit_card: this.getCardOrder(checkout, card),
+                }),
+            },
+        ];
+    }
+    static getPixOrder() {
+        return {
+            expires_at: dateFns.format(dateFns.addHours(new Date(), 24), "yyyy-MM-dd'T'HH:mm:ss.SSSxxx"),
+        };
+    }
+    static getBoletoOrder() {
+        return {
+            due_at: dateFns.format(dateFns.addDays(new Date(), 3), 'yyyy-MM-dd') + 'T23:59:59.999-03:00',
+            instructions: 'Sr. Caixa, NÃO aceitar o pagamento após o vencimento.',
+            type: 'DM',
+            document_number: new Date().getTime().toString(),
+        };
+    }
+    static getCardOrder(checkout, card) {
+        return {
+            installments: card.installments,
+            statement_descriptor: checkout.shop === exports.Shops.GLAMSHOP ? 'loja glam' : 'mens market',
+            card_id: card.cardId,
+            card: {
+                cvv: card.cardCvv,
+                billing_address: {
+                    line_1: `${checkout.billingAddress.number}, ${checkout.billingAddress.street}, ${checkout.billingAddress.district}`,
+                    zip_code: checkout.billingAddress.zip,
+                    city: checkout.billingAddress.city,
+                    state: checkout.billingAddress.state,
+                    country: 'BR',
+                },
+            },
+        };
+    }
+    static buildAdditionalInfo(checkout) {
+        const isSubscriber = checkout.user?.isSubscriber ?? false;
+        if (isSubscriber)
+            return {
+                antifraude_enabled: false,
+            };
+        return {};
     }
 }
 
-class PagarmePaymentFactoryHelper {
-    static async createSuccessfulPayment(params) {
-        const { checkout, resultData, paymentRepository } = params;
-        const payment = await paymentRepository.create({
+class PagarMeV5ResponseHelper {
+    static build(method, checkout, response) {
+        return Payment.toInstance({
             createdAt: new Date(),
             updatedAt: new Date(),
             userId: checkout.user.id,
             checkoutId: checkout.id,
             totalPrice: checkout.totalPrice,
             paymentProvider: exports.PaymentProviders.PAGARME,
-            transaction: { ...resultData, paidAt: new Date() },
-        });
-        return payment;
+            pagarMeOrderId: response.id,
+            transaction: this.buildPaymentTransaction(method, response),
+        });
+    }
+    static buildPaymentTransaction(method, response) {
+        const charger = response.charges.at(0);
+        const transaction = charger.last_transaction;
+        return PaymentTransaction.toInstance({
+            acquirer_name: exports.PaymentProviders.PAGARME,
+            amount: charger.amount,
+            currency: charger.currency,
+            gateway_id: charger.gateway_id,
+            status: this.getPaymentStatus(transaction.status),
+            payment_method: charger.payment_method,
+            date_created: charger.created_at,
+            date_updated: charger.updated_at,
+            paid_amount: charger.paid_amount,
+            paid_at: charger.paid_at,
+            order_id: response.id,
+            charger_id: charger.id,
+            tid: charger.id,
+            id: charger.id,
+            ...(method == exports.TransactionPaymentMethods.BANKSLIP && this.getBoletoReponse(transaction)),
+            ...(method == exports.TransactionPaymentMethods.PIX && this.getPixReponse(transaction)),
+            ...(method == exports.TransactionPaymentMethods.CARD && this.getCardReponse(transaction)),
+        });
+    }
+    static getPaymentStatus(status) {
+        if (status == exports.PagarMeV5PaymentStatus.Gerado)
+            return exports.PagarMeV5PaymentStatus['Aguardando pagamento'];
+        if (status == exports.PagarMeV5PaymentStatus.Capturada)
+            return exports.PagarMeV5PaymentStatus.Pago;
+        return status;
+    }
+    static getBoletoReponse(transaction) {
+        return {
+            boleto_url: transaction.url?.toString(),
+            boleto_barcode: transaction.line?.toString(),
+            boleto_qr_code: transaction.qr_code?.toString(),
+            boleto_expiration_date: transaction.due_at?.toString(),
+            boleto_instructions: transaction.instructions?.toString(),
+            boleto_nosso_numero: transaction.nosso_numero?.toString(),
+            boleto_type: transaction.type?.toString(),
+            boleto_document_number: transaction.document_number?.toString(),
+        };
     }
-}
-
-class PagarmePaymentOperationsHelper {
-    static async executePaymentRequest(params) {
-        const { checkout, card, credentials, createPayloadFunction } = params;
-        const payload = createPayloadFunction(checkout, card);
-        console.warn('[PAGARME CARD DATA TO SEND]', payload);
-        const result = await axios__default["default"]({
-            method: 'POST',
-            url: `${credentials.URL}/transactions`,
-            data: payload,
-        });
-        return result;
+    static getPixReponse(transaction) {
+        return {
+            pix_qr_code: transaction.qr_code?.toString(),
+            pix_qr_code_url: transaction.qr_code_url?.toString(),
+            pix_expiration_date: transaction.expires_at?.toString(),
+        };
+    }
+    static getCardReponse(transaction) {
+        return {
+            soft_descriptor: transaction.statement_descriptor?.toString(),
+            acquirer_name: transaction.acquirer_name?.toString(),
+            acquirer_id: transaction.acquirer_tid?.toString(),
+            acquirer_nsu: transaction.acquirer_nsu?.toString(),
+            acquirer_auth_code: transaction.acquirer_auth_code?.toString(),
+            acquirer_message: transaction.acquirer_message?.toString(),
+            acquirer_return_code: transaction.acquirer_return_code?.toString(),
+            installments: transaction.installments ?? null,
+            card_holder_name: transaction.card?.holder_name?.toString(),
+            card_last_digits: transaction.card?.last_four_digits?.toString(),
+            card_first_digits: transaction.card?.first_six_digits?.toString(),
+            card_brand: transaction.card?.brand?.toString(),
+            card_id: transaction.card?.id?.toString(),
+        };
     }
 }
 
@@ -8692,7 +10855,7 @@ class PagarmeCardAxiosAdapter {
                     card,
                     orderBlockedRepository: this.orderBlockedRepository,
                 });
-                throw PagarmeBlockedOrderHelper.createPaymentError(checkout, result.data);
+                throw PagarmeBlockedOrderHelper.createPaymentError(checkout, exports.ErrorsCode.paymentError, result.data);
             }
             return PagarmePaymentFactoryHelper.createSuccessfulPayment({
                 checkout,
@@ -8704,7 +10867,7 @@ class PagarmeCardAxiosAdapter {
             if (error instanceof PaymentError) {
                 throw error;
             }
-            throw PagarmeBlockedOrderHelper.createGenericPaymentError(checkout, error.response?.data);
+            throw PagarmeBlockedOrderHelper.createGenericPaymentError(checkout, exports.ErrorsCode.paymentError, error.response?.data);
         }
     }
     async addCard(card) {
@@ -8728,8 +10891,9 @@ class PagarmeCardAxiosAdapter {
             });
         }
     }
-    async createCardHash(bu) {
-        const key = bu === exports.BusinessUnitEnum.SHOP ? this.credentials.SHOP_API_KEY : this.credentials.SUBSCRIPTION_API_KEY;
+    async createCardHash(bu, shop) {
+        const credentials = shop && shop == exports.Shops.MENSMARKET ? this.credentials[exports.Shops.MENSMARKET] : this.credentials[exports.Shops.GLAMSHOP];
+        const key = bu === exports.BusinessUnitEnum.SHOP ? credentials.SHOP_API_KEY : credentials.SUBSCRIPTION_API_KEY;
         try {
             const { data } = await axios__default["default"]({
                 method: 'GET',
@@ -8860,7 +11024,7 @@ class PagarmePixAxiosAdapter {
             return payment;
         }
         catch (error) {
-            throw new PaymentError('Houve uma falha ao processar pagamento com pix', {
+            throw new PaymentError('Houve uma falha ao processar pagamento com pix', exports.ErrorsCode.paymentError, {
                 checkoutId: checkout.id,
                 userEmail: checkout.user.email,
                 info: error.response?.data,
@@ -8892,6 +11056,341 @@ class PagarmePixAxiosAdapter {
     }
 }
 
+class PagarmeV5BankSlipAxiosAdapter {
+    constructor(credentials, paymentRepository) {
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+    }
+    async pay(checkout) {
+        try {
+            const payload = PagarMeV5RequestHelper.build(checkout, 'boleto');
+            console.warn('[PAGARME BOLETO DATA TO SEND]', JSON.stringify(payload));
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.URL}/orders`,
+                headers: {
+                    Authorization: 'Basic ' + Buffer.from(`${this.credentials.API_KEY}:`).toString('base64'),
+                    'Content-Type': 'application/json',
+                },
+                data: payload,
+            });
+            console.warn('[PAGARME RESPONSE BOLETO DATA]', JSON.stringify(data));
+            if (data.status === exports.PagarMeV5OrderStatus.Falha ||
+                data.charges.at(0).status === exports.PagarMeV5OrderStatus.Falha ||
+                (data.charges.at(0).last_transaction.status !== exports.PagarMeV5PaymentStatus.Gerado &&
+                    data.charges.at(0).last_transaction.status !== exports.PagarMeV5PaymentStatus['Em processamento'])) {
+                return Promise.reject(new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', exports.ErrorsCode.paymentError, {
+                    checkoutId: checkout.id,
+                    userEmail: checkout.user.email,
+                    info: data.charges.at(0).last_transaction?.gateway_response,
+                }));
+            }
+            const payment = await this.paymentRepository.create(PagarMeV5ResponseHelper.build(exports.TransactionPaymentMethods.BANKSLIP, checkout, data));
+            return payment;
+        }
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.error('error data: ', JSON.stringify(error.response?.data));
+            }
+            throw new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', exports.ErrorsCode.paymentError, {
+                checkoutId: checkout.id,
+                userEmail: checkout.user.email,
+                info: error.response?.data,
+            });
+        }
+    }
+    async getBoletoTransaction(paymentId) {
+        try {
+            const { data } = await axios__default["default"]({
+                method: 'GET',
+                url: `${this.credentials.URL}/charges/${paymentId}`,
+                headers: {
+                    Authorization: 'Basic ' + Buffer.from(`${this.credentials.API_KEY}:`).toString('base64'),
+                    'Content-Type': 'application/json',
+                },
+            });
+            const payment = await this.paymentRepository.get({
+                id: data.id,
+            });
+            return payment.transaction;
+        }
+        catch (error) {
+            throw new BusinessError('Houve uma falha buscar o boleto com paymentId: ' + paymentId, {
+                paymentId,
+                info: error.response.data,
+            });
+        }
+    }
+}
+
+class PagarmeV5BaseAxiosAdapter {
+    constructor(credentials, paymentRepository) {
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+    }
+    async refund(order, amount) {
+        try {
+            console.warn('[PAGARME REFUND] Starting refund process for order', order.id, order.payment, 'with amount', amount);
+            const amountToSend = +amount.toFixed(2) * 100;
+            console.warn('[PAGARME REFUND] Amount to send in cents', amountToSend);
+            const { data } = await axios__default["default"]({
+                method: 'DELETE',
+                url: `${this.credentials.URL}/charges/${order.payment.charger_id}`,
+                headers: {
+                    Authorization: 'Basic ' + Buffer.from(`${this.credentials.API_KEY}:`).toString('base64'),
+                    'Content-Type': 'application/json',
+                },
+                data: {
+                    amount: amountToSend,
+                },
+            });
+            console.warn('[RESPONSE PAGARME REFUND]', JSON.stringify(data));
+            await this.paymentRepository.create({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                userId: order.user.id,
+                orderId: order.id,
+                totalPrice: amount,
+                paymentProvider: exports.PaymentProviders.PAGARME,
+                pagarMeOrderId: data.id,
+                transaction: data,
+            });
+            return {
+                status: this.getRefundStatus(data.status),
+                success: [exports.PagarMeV5OrderStatus.Pago, exports.PagarMeV5OrderStatus.Cancelado].includes(data.status) ? true : false,
+            };
+        }
+        catch (error) {
+            console.error('Error during refund process for order', order.id, 'with error', error);
+            throw error;
+        }
+    }
+    getRefundStatus(status) {
+        if ([exports.PagarMeV5PaymentStatus['Em processamento']].includes(status)) {
+            return 'processing';
+        }
+        if ([exports.PagarMeV5OrderStatus.Pago, exports.PagarMeV5OrderStatus.Cancelado].includes(status)) {
+            return 'success';
+        }
+        return 'unknown';
+    }
+}
+
+class PagarmeV5CardAxiosAdapter extends PagarmeV5BaseAxiosAdapter {
+    constructor(credentials, paymentRepository, orderBlockedRepository) {
+        super(credentials, paymentRepository);
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+        this.orderBlockedRepository = orderBlockedRepository;
+    }
+    async pay(checkout, card) {
+        try {
+            const payload = PagarMeV5RequestHelper.build(checkout, 'credit_card', card);
+            console.warn('[PAGARME CARD DATA TO SEND]', JSON.stringify(payload));
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.URL}/orders`,
+                headers: {
+                    Authorization: 'Basic ' + Buffer.from(`${this.credentials.API_KEY}:`).toString('base64'),
+                    'Content-Type': 'application/json',
+                },
+                data: payload,
+            });
+            console.warn('[RESPONSE PAGARME CARD DATA]', JSON.stringify(data));
+            const charge = data.charges.at(0);
+            if (data.status == exports.PagarMeV5OrderStatus.Falha ||
+                charge.status !== exports.PagarMeV5OrderStatus.Pago ||
+                charge.last_transaction.status !== exports.PagarMeV5PaymentStatus.Capturada) {
+                await PagarmeBlockedOrderHelper.createBlockedOrderForUnauthorizedCard({
+                    checkout,
+                    card,
+                    orderBlockedRepository: this.orderBlockedRepository,
+                    gatewayInfo: {
+                        gateway: exports.PaymentProviders.PAGARME,
+                        status: charge.status,
+                        statusDetail: charge.last_transaction?.status,
+                    },
+                });
+                const errorCode = PagarMeErrorHelper.getErrorTypeFromResponse(charge.last_transaction.acquirer_return_code);
+                throw PagarmeBlockedOrderHelper.createPaymentError(checkout, errorCode, data);
+            }
+            const payment = await this.paymentRepository.create(PagarMeV5ResponseHelper.build(exports.TransactionPaymentMethods.CARD, checkout, data));
+            return payment;
+        }
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.error('error data: ', JSON.stringify(error.response?.data));
+                throw PagarmeBlockedOrderHelper.createGenericPaymentError(checkout, exports.ErrorsCode.paymentError, error.response?.data);
+            }
+            throw error;
+        }
+    }
+    async addCard(card, customer) {
+        try {
+            const { id } = await this.createOrUpdateCustomer(customer);
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.URL}/customers/${id}/cards`,
+                headers: {
+                    Authorization: 'Basic ' + Buffer.from(`${this.credentials.API_KEY}:`).toString('base64'),
+                    'Content-Type': 'application/json',
+                },
+                data: {
+                    number: card.number,
+                    holder_name: card.name,
+                    holder_document: card.cpf,
+                    exp_month: card.expirationDate.split('/').at(0),
+                    exp_year: card.expirationDate.split('/').at(1),
+                    cvv: card.cvv,
+                    billing_address: {
+                        line_1: `${customer.billingAddress.number}, ${customer.billingAddress.street}, ${customer.billingAddress.district}`,
+                        line_2: `${customer.billingAddress.extension}`,
+                        zip_code: customer.billingAddress.zip,
+                        city: customer.billingAddress.city,
+                        state: customer.billingAddress.state,
+                        country: 'BR',
+                    },
+                },
+            });
+            return data;
+        }
+        catch (error) {
+            console.warn(JSON.stringify(error));
+            throw error;
+        }
+    }
+    async createCardHash(bu, shop) {
+        const credentials = shop && shop == exports.Shops.MENSMARKET ? this.credentials[exports.Shops.MENSMARKET] : this.credentials[exports.Shops.GLAMSHOP];
+        const key = bu === exports.BusinessUnitEnum.SHOP ? credentials.SHOP_API_KEY : credentials.SUBSCRIPTION_API_KEY;
+        try {
+            const { data } = await axios__default["default"]({
+                method: 'GET',
+                headers: {
+                    'content-type': 'application/json',
+                },
+                url: `${this.credentials.URL}/transactions/card_hash_key`,
+                data: JSON.stringify({
+                    api_key: key,
+                }),
+            });
+            return data;
+        }
+        catch (error) {
+            throw new BusinessError('Houve uma falha gerar o hash', {
+                info: error.response.data,
+            });
+        }
+    }
+    async getCardByToken(customerId, token) {
+        try {
+            const { data } = await axios__default["default"]({
+                method: 'GET',
+                url: `${this.credentials.URL}/cards/${token}`,
+                data: {
+                    api_key: this.credentials.API_KEY,
+                },
+            });
+            return data;
+        }
+        catch (error) {
+            throw new BusinessError('Houve uma falha buscar o cartão com id: ' + token, {
+                info: error.response.data,
+            });
+        }
+    }
+    async createTransaction(info) {
+        return info;
+    }
+    async createOrUpdateCustomer(customer) {
+        try {
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.URL}/customers`,
+                headers: {
+                    Authorization: 'Basic ' + Buffer.from(`${this.credentials.API_KEY}:`).toString('base64'),
+                    'Content-Type': 'application/json',
+                },
+                data: {
+                    name: customer.displayName,
+                    email: customer.email,
+                    document: customer.cpf,
+                    type: 'individual',
+                    document_type: 'CPF',
+                    address: {
+                        line_1: `${customer.billingAddress.number}, ${customer.billingAddress.street}, ${customer.billingAddress.district}`,
+                        line_2: `${customer.billingAddress.extension}`,
+                        zip_code: customer.billingAddress.zip,
+                        city: customer.billingAddress.city,
+                        state: customer.billingAddress.state,
+                        country: 'BR',
+                    },
+                    birthdate: dateFns.format(new Date(customer.birthday), 'MM/dd/yyyy'),
+                    phones: {
+                        home_phone: {
+                            country_code: '55',
+                            number: customer.phone.slice(2),
+                            area_code: customer.phone.slice(0, 2),
+                        },
+                        mobile_phone: {
+                            country_code: '55',
+                            number: customer.phone.slice(2),
+                            area_code: customer.phone.slice(0, 2),
+                        },
+                    },
+                },
+            });
+            return data;
+        }
+        catch (error) {
+            console.warn(error);
+            throw error;
+        }
+    }
+}
+
+class PagarmeV5PixAxiosAdapter extends PagarmeV5BaseAxiosAdapter {
+    constructor(credentials, paymentRepository) {
+        super(credentials, paymentRepository);
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+    }
+    async pay(checkout) {
+        try {
+            const payload = PagarMeV5RequestHelper.build(checkout, 'pix');
+            console.warn('[PAGARME PIX DATA TO SEND]', JSON.stringify(payload));
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.URL}/orders`,
+                headers: {
+                    Authorization: 'Basic ' + Buffer.from(`${this.credentials.API_KEY}:`).toString('base64'),
+                    'Content-Type': 'application/json',
+                },
+                data: payload,
+            });
+            console.warn('[RESPONSE PAGARME PIX DATA]', JSON.stringify(data));
+            if (data.status == exports.PagarMeV5OrderStatus.Falha || data.status == exports.PagarMeV5OrderStatus.Cancelado) {
+                throw new PaymentError('Houve uma falha ao processar pagamento com pix', exports.ErrorsCode.paymentError, {
+                    checkoutId: checkout.id,
+                    userEmail: checkout.user.email,
+                    info: data.charges.at(0).last_transaction?.gateway_response,
+                });
+            }
+            const payment = await this.paymentRepository.create(PagarMeV5ResponseHelper.build(exports.TransactionPaymentMethods.PIX, checkout, data));
+            return payment;
+        }
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.error('error data: ', JSON.stringify(error.response?.data));
+            }
+            throw new PaymentError('Houve uma falha ao processar pagamento com pix', exports.ErrorsCode.paymentError, {
+                checkoutId: checkout.id,
+                userEmail: checkout.user.email,
+                info: error.response?.data,
+            });
+        }
+    }
+}
+
 class VertexAxiosAdapter {
     constructor(config) {
         this.config = config;
@@ -9057,6 +11556,10 @@ Object.defineProperty(exports, 'addDays', {
   enumerable: true,
   get: function () { return dateFns.addDays; }
 });
+Object.defineProperty(exports, 'addHours', {
+  enumerable: true,
+  get: function () { return dateFns.addHours; }
+});
 Object.defineProperty(exports, 'addMonths', {
   enumerable: true,
   get: function () { return dateFns.addMonths; }
@@ -9093,6 +11596,10 @@ Object.defineProperty(exports, 'subDays', {
   enumerable: true,
   get: function () { return dateFns.subDays; }
 });
+Object.defineProperty(exports, 'formatInTimeZone', {
+  enumerable: true,
+  get: function () { return dateFnsTz.formatInTimeZone; }
+});
 Object.defineProperty(exports, 'chunk', {
   enumerable: true,
   get: function () { return lodash.chunk; }
@@ -9180,6 +11687,8 @@ exports.Base = Base;
 exports.BaseModel = BaseModel;
 exports.BeautyProfile = BeautyProfile;
 exports.BeautyQuestionsHelper = BeautyQuestionsHelper;
+exports.BrandCategory = BrandCategory;
+exports.BrandCategoryFirestoreRepository = BrandCategoryFirestoreRepository;
 exports.BusinessError = BusinessError;
 exports.Buy2Win = Buy2Win;
 exports.Buy2WinFirestoreRepository = Buy2WinFirestoreRepository;
@@ -9228,6 +11737,7 @@ exports.GroupFirestoreRepository = GroupFirestoreRepository;
 exports.Home = Home;
 exports.HomeFirestoreRepository = HomeFirestoreRepository;
 exports.InvalidArgumentError = InvalidArgumentError;
+exports.InvalidCheckoutError = InvalidCheckoutError;
 exports.KitProduct = KitProduct;
 exports.KitProductHasuraGraphQL = KitProductHasuraGraphQL;
 exports.Lead = Lead;
@@ -9238,6 +11748,13 @@ exports.Log = Log;
 exports.LogDocument = LogDocument;
 exports.LogFirestoreRepository = LogFirestoreRepository;
 exports.Logger = Logger;
+exports.MercadoPagoBankSlipAxiosAdapter = MercadoPagoBankSlipAxiosAdapter;
+exports.MercadoPagoCardAxiosAdapter = MercadoPagoCardAxiosAdapter;
+exports.MercadoPagoErrorHelper = MercadoPagoErrorHelper;
+exports.MercadoPagoPaymentMethodFactory = MercadoPagoPaymentMethodFactory;
+exports.MercadoPagoPixAxiosAdapter = MercadoPagoPixAxiosAdapter;
+exports.MercadoPagoRequestHelper = MercadoPagoRequestHelper;
+exports.MercadoPagoResponseHelper = MercadoPagoResponseHelper;
 exports.NotFoundError = NotFoundError;
 exports.ObsEmitter = ObsEmitter;
 exports.Order = Order;
@@ -9248,20 +11765,33 @@ exports.PagarmeBankSlipAxiosAdapter = PagarmeBankSlipAxiosAdapter;
 exports.PagarmeCardAxiosAdapter = PagarmeCardAxiosAdapter;
 exports.PagarmePaymentMethodFactory = PagarmePaymentMethodFactory;
 exports.PagarmePixAxiosAdapter = PagarmePixAxiosAdapter;
+exports.PagarmeV5BankSlipAxiosAdapter = PagarmeV5BankSlipAxiosAdapter;
+exports.PagarmeV5BaseAxiosAdapter = PagarmeV5BaseAxiosAdapter;
+exports.PagarmeV5CardAxiosAdapter = PagarmeV5CardAxiosAdapter;
+exports.PagarmeV5PixAxiosAdapter = PagarmeV5PixAxiosAdapter;
 exports.Payment = Payment;
 exports.PaymentError = PaymentError;
 exports.PaymentFirestoreRepository = PaymentFirestoreRepository;
 exports.PaymentProviderFactory = PaymentProviderFactory;
 exports.PaymentTransaction = PaymentTransaction;
 exports.Product = Product;
+exports.ProductCatalogHasuraGraphQL = ProductCatalogHasuraGraphQL;
+exports.ProductCatalogHasuraGraphQLRepository = ProductCatalogHasuraGraphQLRepository;
 exports.ProductErrors = ProductErrors;
 exports.ProductErrorsHasuraGraphQL = ProductErrorsHasuraGraphQL;
 exports.ProductErrorsHasuraGraphQLRepository = ProductErrorsHasuraGraphQLRepository;
 exports.ProductFirestoreRepository = ProductFirestoreRepository;
+exports.ProductGroup = ProductGroup;
+exports.ProductGroupHasuraGraphQLRepository = ProductGroupHasuraGraphQLRepository;
 exports.ProductHasuraGraphQL = ProductHasuraGraphQL;
 exports.ProductHasuraGraphQLRepository = ProductHasuraGraphQLRepository;
+exports.ProductPriceLog = ProductPriceLog;
+exports.ProductPriceLogHasuraGraphQLRepository = ProductPriceLogHasuraGraphQLRepository;
 exports.ProductReview = ProductReview;
 exports.ProductReviewHasuraGraphQLRepository = ProductReviewHasuraGraphQLRepository;
+exports.ProductStockEntry = ProductStockEntry;
+exports.ProductStockEntryHasuraGraphQL = ProductStockEntryHasuraGraphQL;
+exports.ProductStockEntryHasuraGraphQLRepository = ProductStockEntryHasuraGraphQLRepository;
 exports.ProductStockNotification = ProductStockNotification;
 exports.ProductStockNotificationHasuraGraphQLRepository = ProductStockNotificationHasuraGraphQLRepository;
 exports.ProductVariantFirestoreRepository = ProductVariantFirestoreRepository;
@@ -9277,10 +11807,18 @@ exports.RoundProductPricesHelper = RoundProductPricesHelper;
 exports.Sequence = Sequence;
 exports.SequenceFirestoreRepository = SequenceFirestoreRepository;
 exports.ShippingMethod = ShippingMethod;
+exports.ShopConfigs = ShopConfigs;
+exports.ShopConfigsFirestoreRepository = ShopConfigsFirestoreRepository;
 exports.ShopMenu = ShopMenu;
 exports.ShopMenuFirestoreRepository = ShopMenuFirestoreRepository;
 exports.ShopSettings = ShopSettings;
 exports.ShopSettingsFirestoreRepository = ShopSettingsFirestoreRepository;
+exports.ShoppingRecurrence = ShoppingRecurrence;
+exports.ShoppingRecurrenceEdition = ShoppingRecurrenceEdition;
+exports.ShoppingRecurrenceEditionFirestoreRepository = ShoppingRecurrenceEditionFirestoreRepository;
+exports.ShoppingRecurrenceErrorLog = ShoppingRecurrenceErrorLog;
+exports.ShoppingRecurrenceErrorLogFirestoreRepository = ShoppingRecurrenceErrorLogFirestoreRepository;
+exports.ShoppingRecurrenceFirestoreRepository = ShoppingRecurrenceFirestoreRepository;
 exports.SignOut = SignOut;
 exports.StockLimitError = StockLimitError;
 exports.StockOutError = StockOutError;