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

package/index.cjs.js

@@ -20,25 +20,7 @@ var storage = require('firebase/storage');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var serializeJavascript__namespace = /*#__PURE__*/_interopNamespace(serializeJavascript);
+var serializeJavascript__default = /*#__PURE__*/_interopDefaultLegacy(serializeJavascript);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 
 exports.AntifraudProviders = void 0;
@@ -175,6 +157,123 @@ class PaymentProviderFactory {
     }
 }
 
+const ANTIFRAUD_CONFIG_CACHE_TTL_SECONDS = 60;
+/**
+ * Lê `shopConfigs.antifraude.enabled`.
+ * - `false` explícito → antifraude desligado
+ * - ausente / erro / inválido → `true` (mantém comportamento histórico)
+ */
+async function isAntifraudEnabled(shopConfigsRepository) {
+    if (!shopConfigsRepository) {
+        return true;
+    }
+    try {
+        const result = await shopConfigsRepository.find({}, { cache: { enabled: true, ttl: ANTIFRAUD_CONFIG_CACHE_TTL_SECONDS } });
+        const enabled = result?.data?.at(0)?.antifraude?.enabled;
+        if (typeof enabled === 'boolean') {
+            return enabled;
+        }
+        return true;
+    }
+    catch (error) {
+        console.warn(JSON.stringify({
+            msg: 'antifraud_enabled_config_load_failed',
+            enabled: true,
+            error: error instanceof Error ? error.message : String(error),
+        }));
+        return true;
+    }
+}
+
+/** Defaults de runtime (week.zip = Infinity). Usados só como fallback no checkout. */
+const DEFAULT_ANTIFRAUD_VOLUME_LIMITS = {
+    enabled: true,
+    source: 'fallback',
+    day: {
+        subscriber: { cpf: 4, email: 4, phone: 4, card: 4, zip: 4 },
+        nonSubscriber: { cpf: 2, email: 2, phone: 2, card: 2, zip: 2 },
+    },
+    week: {
+        subscriber: { cpf: 12, email: 12, phone: 12, card: 12, zip: Infinity },
+        nonSubscriber: { cpf: 7, email: 7, phone: 7, card: 7, zip: Infinity },
+    },
+    blockedAttemptsDay: {
+        subscriber: 7,
+        nonSubscriber: 5,
+    },
+};
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 1 && Number.isInteger(value);
+}
+function normalizeLimitOrders(raw, allowInfiniteZip) {
+    if (!raw)
+        return null;
+    const zip = allowInfiniteZip && (raw.zip === null || raw.zip === undefined || raw.zip === Infinity) ? Infinity : raw.zip;
+    const normalized = {
+        cpf: raw.cpf,
+        email: raw.email,
+        phone: raw.phone,
+        zip: zip,
+        card: raw.card,
+    };
+    for (const key of ['cpf', 'email', 'phone', 'zip', 'card']) {
+        if (key === 'zip' && normalized.zip === Infinity)
+            continue;
+        if (!isPositiveInteger(normalized[key]))
+            return null;
+    }
+    return normalized;
+}
+function cloneFallbackLimits() {
+    return {
+        ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS,
+        day: {
+            subscriber: { ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS.day.subscriber },
+            nonSubscriber: { ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS.day.nonSubscriber },
+        },
+        week: {
+            subscriber: { ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS.week.subscriber },
+            nonSubscriber: { ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS.week.nonSubscriber },
+        },
+        blockedAttemptsDay: { ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS.blockedAttemptsDay },
+        source: 'fallback',
+    };
+}
+/** Config inválida/ausente → fallback (comportamento histórico). */
+function resolveAntifraudVolumeLimits(antifraude) {
+    if (!antifraude || typeof antifraude.enabled !== 'boolean') {
+        return cloneFallbackLimits();
+    }
+    const daySubscriber = normalizeLimitOrders(antifraude.day?.subscriber, false);
+    const dayNonSubscriber = normalizeLimitOrders(antifraude.day?.nonSubscriber, false);
+    const weekSubscriber = normalizeLimitOrders(antifraude.week?.subscriber, true);
+    const weekNonSubscriber = normalizeLimitOrders(antifraude.week?.nonSubscriber, true);
+    const blocked = antifraude.blockedAttemptsDay;
+    if (!daySubscriber ||
+        !dayNonSubscriber ||
+        !weekSubscriber ||
+        !weekNonSubscriber ||
+        !blocked ||
+        !isPositiveInteger(blocked.subscriber) ||
+        !isPositiveInteger(blocked.nonSubscriber)) {
+        // Kill-switch explícito prevalece mesmo com payload inválido.
+        if (antifraude.enabled === false) {
+            return { ...cloneFallbackLimits(), enabled: false, source: 'fallback' };
+        }
+        return cloneFallbackLimits();
+    }
+    return {
+        enabled: antifraude.enabled,
+        source: 'config',
+        day: { subscriber: daySubscriber, nonSubscriber: dayNonSubscriber },
+        week: { subscriber: weekSubscriber, nonSubscriber: weekNonSubscriber },
+        blockedAttemptsDay: {
+            subscriber: blocked.subscriber,
+            nonSubscriber: blocked.nonSubscriber,
+        },
+    };
+}
+
 const registry = new Map();
 function registerClass(name, classConstructor) {
     registry.set(name, classConstructor);
@@ -660,9 +759,22 @@ const deserialize = (data) => {
     return eval('(' + data + ')');
 };
 const serialize = (data) => {
-    return serializeJavascript__namespace(data);
+    return serializeJavascript__default["default"](data);
 };
 
+/**
+ * Converts a BRL major-unit amount (e.g. 10.5) to integer cents (1050).
+ * Uses fixed 2-decimal normalization to avoid IEEE-754 artifacts like 19.99 * 100.
+ */
+function toCents(amount) {
+    if (!Number.isFinite(amount)) {
+        throw new Error(`Invalid amount: ${amount}`);
+    }
+    const sign = amount < 0 ? -1 : 1;
+    const [whole, fraction = '0'] = Math.abs(amount).toFixed(2).split('.');
+    return sign * (Number(whole) * 100 + Number(fraction));
+}
+
 class BaseModel {
     get identifier() {
         const fields = this.constructor.identifiersFields.filter((field) => field !== 'identifier');
@@ -1043,6 +1155,12 @@ class CampaignHashtag extends BaseModel {
     }
 }
 
+class CampaignHashtagPosts extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
 class BeautyProfile extends BaseModel {
     toPlain() {
         const plain = super.toPlain();
@@ -1911,12 +2029,23 @@ class StockOutError extends BusinessError {
     }
 }
 
+/* eslint-disable no-console */
 class AntifraudBankSlipService {
-    constructor(orderBlockedRepository) {
+    constructor(orderBlockedRepository, shopConfigsRepository) {
         this.orderBlockedRepository = orderBlockedRepository;
+        this.shopConfigsRepository = shopConfigsRepository;
         this.MAX_ORDER_VALUE = 5000;
     }
     async validate(checkout) {
+        const enabled = await isAntifraudEnabled(this.shopConfigsRepository);
+        if (!enabled) {
+            console.info(JSON.stringify({
+                msg: 'antifraud_bankslip_skipped',
+                enabled: false,
+                checkoutId: checkout.id,
+            }));
+            return true;
+        }
         if (checkout.totalPrice && checkout.totalPrice > this.MAX_ORDER_VALUE && !checkout.user?.isSubscriber) {
             await this.orderBlockedRepository.createBlockedOrderOrPayment({
                 checkout,
@@ -1938,62 +2067,67 @@ class AntifraudBankSlipService {
     }
 }
 
+/* eslint-disable max-params */
 class AntifraudCardService {
-    constructor(orderRepository, orderBlockedRepository) {
+    constructor(orderRepository, orderBlockedRepository, shopConfigsRepository) {
         this.orderRepository = orderRepository;
         this.orderBlockedRepository = orderBlockedRepository;
-        this.LIMIT_ORDERS_DAY = null;
-        this.LIMIT_ORDERS_WEEK = null;
+        this.shopConfigsRepository = shopConfigsRepository;
     }
     async validate(checkout, card) {
-        this.setLimitsByUserType(checkout.user.isSubscriber);
-        await this.validateBlockedOrderAttempts(checkout, card);
-        await this.validateDayAndWeekOrderLimits(checkout, card);
+        // Limites locais por request — evita race em provider Nest singleton entre awaits.
+        const resolved = await this.loadResolvedLimits();
+        const isSubscriber = !!checkout.user?.isSubscriber;
+        const dayLimits = isSubscriber ? resolved.day.subscriber : resolved.day.nonSubscriber;
+        const weekLimits = isSubscriber ? resolved.week.subscriber : resolved.week.nonSubscriber;
+        const blockedAttemptsDay = isSubscriber
+            ? resolved.blockedAttemptsDay.subscriber
+            : resolved.blockedAttemptsDay.nonSubscriber;
+        if (!resolved.enabled) {
+            console.info(JSON.stringify({
+                msg: 'antifraud_card_volume_skipped',
+                source: resolved.source,
+                enabled: false,
+                checkoutId: checkout.id,
+                isSubscriber,
+            }));
+            return true;
+        }
+        console.info(JSON.stringify({
+            msg: 'antifraud_card_volume_limits',
+            source: resolved.source,
+            enabled: true,
+            checkoutId: checkout.id,
+            isSubscriber,
+            blockedAttemptsDay,
+            day: dayLimits,
+            week: weekLimits,
+        }));
+        await this.validateBlockedOrderAttempts(checkout, card, blockedAttemptsDay);
+        await this.validateDayAndWeekOrderLimits(checkout, card, dayLimits, weekLimits);
         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 loadResolvedLimits() {
+        if (!this.shopConfigsRepository) {
+            return resolveAntifraudVolumeLimits(null);
+        }
+        try {
+            const result = await this.shopConfigsRepository.find({}, { cache: { enabled: true, ttl: ANTIFRAUD_CONFIG_CACHE_TTL_SECONDS } });
+            return resolveAntifraudVolumeLimits(result?.data?.at(0)?.antifraude);
+        }
+        catch (error) {
+            console.warn(JSON.stringify({
+                msg: 'antifraud_card_volume_config_load_failed',
+                source: 'fallback',
+                error: error instanceof Error ? error.message : String(error),
+            }));
+            return resolveAntifraudVolumeLimits(null);
+        }
     }
-    async validateBlockedOrderAttempts(checkout, card) {
-        const isValid = await this.verifyBlockedOrderAttempts(checkout, card);
+    async validateBlockedOrderAttempts(checkout, card, blockedAttemptsDay) {
+        const isValid = await this.verifyBlockedOrderAttempts(checkout, card, blockedAttemptsDay);
         if (!isValid) {
-            throw new FraudValidationError(`Cliente com mais de ${this.LIMIT_BLOCKED_ORDERS_DAY} compras negadas/bloqueadas no dia`, exports.ErrorsCode.fraudPreventionInternal, {
+            throw new FraudValidationError(`Cliente com mais de ${blockedAttemptsDay} compras negadas/bloqueadas no dia`, exports.ErrorsCode.fraudPreventionInternal, {
                 checkoutId: checkout.id,
                 userEmail: checkout.user.email,
                 info: {
@@ -2004,8 +2138,8 @@ class AntifraudCardService {
             });
         }
     }
-    async validateDayAndWeekOrderLimits(checkout, card) {
-        const isValid = await this.verifyDayAndWeekOrders(checkout, card);
+    async validateDayAndWeekOrderLimits(checkout, card, dayLimits, weekLimits) {
+        const isValid = await this.verifyDayAndWeekOrders(checkout, card, dayLimits, weekLimits);
         if (!isValid) {
             throw new FraudValidationError('Cliente tentando comprar mais do que o permitido no dia/semana', exports.ErrorsCode.fraudPreventionInternal, {
                 checkoutId: checkout.id,
@@ -2018,15 +2152,15 @@ class AntifraudCardService {
             });
         }
     }
-    async verifyBlockedOrderAttempts(checkout, card) {
+    async verifyBlockedOrderAttempts(checkout, card, blockedAttemptsDay) {
         const dateRange = this.getTodayDateRange();
         const blockedOrders = await this.getBlockedOrdersByMultipleCriteria(checkout, dateRange);
         const totalBlockedAttempts = this.calculateUniqueBlockedAttempts(blockedOrders, checkout);
-        if (totalBlockedAttempts >= this.LIMIT_BLOCKED_ORDERS_DAY) {
+        if (totalBlockedAttempts >= blockedAttemptsDay) {
             await this.createBlockedOrderRecord({
                 checkout,
                 card,
-                reason: `More than ${this.LIMIT_BLOCKED_ORDERS_DAY} attempts have failed`,
+                reason: `More than ${blockedAttemptsDay} attempts have failed`,
                 key: 'Failed attempts',
                 period: 'day',
             });
@@ -2128,12 +2262,12 @@ class AntifraudCardService {
             card,
         });
     }
-    async verifyDayAndWeekOrders(checkout, card) {
+    async verifyDayAndWeekOrders(checkout, card, dayLimits, weekLimits) {
         const validationParams = this.buildValidationParams(checkout, card);
-        const isDayLimitValid = await this.validateDayOrderLimits(checkout, validationParams);
+        const isDayLimitValid = await this.validateDayOrderLimits(checkout, validationParams, dayLimits);
         if (!isDayLimitValid)
             return false;
-        const isWeekLimitValid = await this.validateWeekOrderLimits(checkout, validationParams);
+        const isWeekLimitValid = await this.validateWeekOrderLimits(checkout, validationParams, weekLimits);
         return isWeekLimitValid;
     }
     buildValidationParams(checkout, card) {
@@ -2145,9 +2279,8 @@ class AntifraudCardService {
             card,
         };
     }
-    async validateDayOrderLimits(checkout, params) {
+    async validateDayOrderLimits(checkout, params, limits) {
         const ordersPerDay = await this.validateOrdersByRange(params, this.getDateRange('day'));
-        const limits = this.getLimitsByUserType('day', checkout.user.isSubscriber);
         return this.checkOrderLimitsAndBlock({
             checkout,
             orderCounts: ordersPerDay,
@@ -2155,9 +2288,8 @@ class AntifraudCardService {
             period: 'day',
         });
     }
-    async validateWeekOrderLimits(checkout, params) {
+    async validateWeekOrderLimits(checkout, params, limits) {
         const ordersPerWeek = await this.validateOrdersByRange(params, this.getDateRange('week'));
-        const limits = this.getLimitsByUserType('week', checkout.user.isSubscriber);
         return this.checkOrderLimitsAndBlock({
             checkout,
             orderCounts: ordersPerWeek,
@@ -2234,15 +2366,35 @@ class AntifraudCardService {
 }
 
 class AntifraudGlampointsService {
-    constructor() { }
-    async validate(_checkout) {
+    constructor(shopConfigsRepository) {
+        this.shopConfigsRepository = shopConfigsRepository;
+    }
+    async validate(checkout) {
+        const enabled = await isAntifraudEnabled(this.shopConfigsRepository);
+        if (!enabled) {
+            console.info(JSON.stringify({
+                msg: 'antifraud_glampoints_skipped',
+                enabled: false,
+                checkoutId: checkout.id,
+            }));
+        }
         return true;
     }
 }
 
 class AntifraudPixService {
-    constructor() { }
-    async validate(_checkout) {
+    constructor(shopConfigsRepository) {
+        this.shopConfigsRepository = shopConfigsRepository;
+    }
+    async validate(checkout) {
+        const enabled = await isAntifraudEnabled(this.shopConfigsRepository);
+        if (!enabled) {
+            console.info(JSON.stringify({
+                msg: 'antifraud_pix_skipped',
+                enabled: false,
+                checkoutId: checkout.id,
+            }));
+        }
         return true;
     }
 }
@@ -2596,6 +2748,26 @@ class ShopSettings extends BaseModel {
     }
 }
 
+/**
+ * Defaults iguais ao hardcode histórico do checkout.
+ * `week.*.zip = null` → Infinity no runtime do volume de cartão.
+ */
+const DEFAULT_SHOP_ANTIFRAUD_CONFIG = {
+    enabled: true,
+    day: {
+        subscriber: { cpf: 4, email: 4, phone: 4, card: 4, zip: 4 },
+        nonSubscriber: { cpf: 2, email: 2, phone: 2, card: 2, zip: 2 },
+    },
+    week: {
+        subscriber: { cpf: 12, email: 12, phone: 12, card: 12, zip: null },
+        nonSubscriber: { cpf: 7, email: 7, phone: 7, card: 7, zip: null },
+    },
+    blockedAttemptsDay: {
+        subscriber: 7,
+        nonSubscriber: 5,
+    },
+};
+
 class AdyenBlockedOrderHelper {
     static async handleUnauthorizedPayment(params) {
         await params.orderBlockedRepository.createBlockedOrderOrPayment({
@@ -2720,11 +2892,39 @@ class AdyenCardAxiosAdapter {
     }
 }
 
+function resolveCacheConfig(cache) {
+    if (lodash.isNil(cache) || typeof cache !== 'object')
+        return undefined;
+    const candidate = cache;
+    const cacheAdapter = candidate.cacheAdapter;
+    if (!cacheAdapter)
+        return undefined;
+    if (!isCacheAdapter(cacheAdapter))
+        return undefined;
+    if (typeof cacheAdapter.isConfigured === 'function' && !cacheAdapter.isConfigured()) {
+        return undefined;
+    }
+    return {
+        cacheAdapter,
+        ttlDefault: candidate.ttlDefault,
+    };
+}
+function isCacheAdapter(adapter) {
+    return (typeof adapter.get === 'function' &&
+        typeof adapter.set === 'function' &&
+        typeof adapter.remove === 'function' &&
+        typeof adapter.clear === 'function');
+}
+
 class RestCacheAdapter {
     constructor(config) {
+        this.client = null;
         this.logger = new DebugHelper('RestCacheAdapter');
+        this.configured = this.isValidBaseURL(config.baseURL);
+        if (!this.configured)
+            return;
         this.client = axios__default["default"].create({
-            baseURL: config.baseURL,
+            baseURL: config.baseURL.trim(),
             headers: {
                 'Content-Type': 'application/json',
                 ...(lodash.isNil(config.authToken) ? {} : { Authorization: `Bearer ${config.authToken}` }),
@@ -2732,7 +2932,12 @@ class RestCacheAdapter {
             },
         });
     }
+    isConfigured() {
+        return this.configured;
+    }
     async set(options) {
+        if (!this.client)
+            return false;
         try {
             const response = await this.client.post('/redis/set', {
                 key: options.key,
@@ -2748,6 +2953,8 @@ class RestCacheAdapter {
         }
     }
     async get(key) {
+        if (!this.client)
+            return null;
         try {
             const response = await this.client.post('/redis/get', {
                 key,
@@ -2764,6 +2971,8 @@ class RestCacheAdapter {
         }
     }
     async remove(key) {
+        if (!this.client)
+            return false;
         try {
             const response = await this.client.post('/redis/del', {
                 key,
@@ -2777,6 +2986,8 @@ class RestCacheAdapter {
         }
     }
     async clear() {
+        if (!this.client)
+            return false;
         try {
             const response = await this.client.post('/redis/flushdb', {});
             return response.data.success;
@@ -2787,6 +2998,9 @@ class RestCacheAdapter {
             return false;
         }
     }
+    isValidBaseURL(baseURL) {
+        return lodash.isString(baseURL) && baseURL.trim().length > 0;
+    }
 }
 
 class AxiosAdapter {
@@ -5437,7 +5651,7 @@ class CampaignHashtagFirestoreRepository extends withCrudFirestore(withHelpers(w
     constructor({ firestore, interceptors, cache, }) {
         super({
             firestore,
-            collectionName: 'hashtagCampaignsAuto',
+            collectionName: 'CampaignsHashtags',
             model: CampaignHashtag,
             interceptors,
             cache,
@@ -5445,6 +5659,18 @@ class CampaignHashtagFirestoreRepository extends withCrudFirestore(withHelpers(w
     }
 }
 
+class CampaignHashtagPostsFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, cache, }) {
+        super({
+            firestore,
+            collectionName: 'CampaignsHashtagsPosts',
+            model: CampaignHashtagPosts,
+            interceptors,
+            cache,
+        });
+    }
+}
+
 class CheckoutFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
     constructor({ firestore, interceptors, cache, }) {
         super({
@@ -6133,7 +6359,7 @@ function createHasuraGraphQLClass(MixinBase) {
             this.model = options.model;
             this.fields = options.fields || this.model.identifiersFields;
             this.logger = DebugHelper.from(this);
-            this.cache = options.cache;
+            this.cache = resolveCacheConfig(options.cache);
         }
         get headers() {
             return HasuraAuthHelper.buildHeaders(this.authOptions);
@@ -11130,9 +11356,9 @@ class PagarmeV5BaseAxiosAdapter {
     }
     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);
+            console.warn('[PAGARME REFUND] Starting refund process for order', order.id, order.payment.payment_method, order.payment.amount, 'to refund with amount', amount);
+            const amountInCents = toCents(amount);
+            console.warn('[PAGARME REFUND] Amount to send in cents', amountInCents);
             const { data } = await axios__default["default"]({
                 method: 'DELETE',
                 url: `${this.credentials.URL}/charges/${order.payment.charger_id}`,
@@ -11141,7 +11367,7 @@ class PagarmeV5BaseAxiosAdapter {
                     'Content-Type': 'application/json',
                 },
                 data: {
-                    amount: amountToSend,
+                    amount: amountInCents,
                 },
             });
             console.warn('[RESPONSE PAGARME REFUND]', JSON.stringify(data));
@@ -11157,7 +11383,13 @@ class PagarmeV5BaseAxiosAdapter {
             });
             return {
                 status: this.getRefundStatus(data.status),
-                success: [exports.PagarMeV5OrderStatus.Pago, exports.PagarMeV5OrderStatus.Cancelado].includes(data.status) ? true : false,
+                success: [
+                    exports.PagarMeV5OrderStatus.Pago,
+                    exports.PagarMeV5OrderStatus.Cancelado,
+                    exports.PagarMeV5PaymentStatus['Em processamento'],
+                ].includes(data.status)
+                    ? true
+                    : false,
             };
         }
         catch (error) {
@@ -11672,6 +11904,7 @@ Object.defineProperty(exports, 'unset', {
   enumerable: true,
   get: function () { return lodash.unset; }
 });
+exports.ANTIFRAUD_CONFIG_CACHE_TTL_SECONDS = ANTIFRAUD_CONFIG_CACHE_TTL_SECONDS;
 exports.Address = Address;
 exports.AdyenCardAxiosAdapter = AdyenCardAxiosAdapter;
 exports.AdyenPaymentMethodFactory = AdyenPaymentMethodFactory;
@@ -11698,6 +11931,8 @@ exports.CampaignDashboard = CampaignDashboard;
 exports.CampaignDashboardFirestoreRepository = CampaignDashboardFirestoreRepository;
 exports.CampaignHashtag = CampaignHashtag;
 exports.CampaignHashtagFirestoreRepository = CampaignHashtagFirestoreRepository;
+exports.CampaignHashtagPosts = CampaignHashtagPosts;
+exports.CampaignHashtagPostsFirestoreRepository = CampaignHashtagPostsFirestoreRepository;
 exports.Category = Category;
 exports.CategoryCollectionChildren = CategoryCollectionChildren;
 exports.CategoryCollectionChildrenHasuraGraphQLRepository = CategoryCollectionChildrenHasuraGraphQLRepository;
@@ -11719,6 +11954,8 @@ exports.ConnectDocumentService = ConnectDocumentService;
 exports.ConnectFirestoreService = ConnectFirestoreService;
 exports.Coupon = Coupon;
 exports.CouponFirestoreRepository = CouponFirestoreRepository;
+exports.DEFAULT_ANTIFRAUD_VOLUME_LIMITS = DEFAULT_ANTIFRAUD_VOLUME_LIMITS;
+exports.DEFAULT_SHOP_ANTIFRAUD_CONFIG = DEFAULT_SHOP_ANTIFRAUD_CONFIG;
 exports.Debug = Debug;
 exports.DebugDecoratorHelper = DebugDecoratorHelper;
 exports.DebugHelper = DebugHelper;
@@ -11855,12 +12092,16 @@ exports.WishlistHasuraGraphQLRepository = WishlistHasuraGraphQLRepository;
 exports.deserialize = deserialize;
 exports.getClass = getClass;
 exports.is = is;
+exports.isAntifraudEnabled = isAntifraudEnabled;
 exports.isDebuggable = isDebuggable;
 exports.isUUID = isUUID;
 exports.parseDateTime = parseDateTime;
 exports.registerClass = registerClass;
+exports.resolveAntifraudVolumeLimits = resolveAntifraudVolumeLimits;
+exports.resolveCacheConfig = resolveCacheConfig;
 exports.resolveClass = resolveClass;
 exports.serialize = serialize;
+exports.toCents = toCents;
 exports.withCreateFirestore = withCreateFirestore;
 exports.withCreateHasuraGraphQL = withCreateHasuraGraphQL;
 exports.withCrudFirestore = withCrudFirestore;