@easyflow/javascript-sdk 2.1.7 → 2.1.9

package/sdk.mjs

@@ -1,945 +0,0 @@
-import { callSecureApi } from './libs/http.mjs'
-import { sanitizeOrderData, Sanitizer } from './libs/sanitizer.mjs'
-import { Validator } from './libs/validator.mjs'
-import { RateLimiter, SECURITY_CONFIG } from './libs/security.mjs'
-import { SecureLogger } from './libs/logger.mjs'
-import { PAYMENT_METHODS, TARGETS } from './libs/constants.mjs'
-import {
-    findPaymentByMethod,
-    isValidBankBilletPayment,
-    isValidPixPayment,
-    mapCreditCardIfNeeded,
-} from './libs/utils.mjs'
-import { throwsError } from './libs/exception-handler.mjs'
-import { NetworkError, SecurityError, ValidationError } from './libs/errors.mjs'
-import { EasyflowIntegrationWrapper, initializeEasyflow, } from './libs/integration-wrapper.mjs'
-
-let SDK_VERSION = '2.1.4'
-try {
-    const versionModule = await import('./version.mjs')
-    SDK_VERSION = versionModule.SDK_VERSION
-} catch (error) {
-    try {
-        if (
-            typeof process !== 'undefined' &&
-            process.versions &&
-            process.versions.node
-        ) {
-            const fs = await import('fs')
-            const path = await import('path')
-            const packagePath = path.join(process.cwd(), 'package.json')
-            const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf8'))
-            SDK_VERSION = packageData.version
-        }
-    } catch (fallbackError) {
-        console.warn(
-            'Could not determine SDK version, using default:',
-            SDK_VERSION
-        )
-    }
-}
-
-/**
- * EasyflowSDK - Main SDK class for Easyflow payment processing
- *
- * This class provides a secure interface for interacting with the Easyflow payment API.
- * It includes built-in security features, rate limiting, and comprehensive error handling.
- *
- * @example
- * ```javascript
- * const sdk = new EasyflowSDK({ businessId: 'your-business-id' });
- * const offer = await sdk.getOffer('offer-id');
- * ```
- *
- * @class EasyflowSDK
- * @since 1.0.0
- */
-class EasyflowSDK {
-    /**
-     * SDK version - dynamically set from package.json
-     * @type {string}
-     * @static
-     * @readonly
-     */
-    static version = SDK_VERSION
-
-    /**
-     * Event listeners storage
-     * @type {Object}
-     * @private
-     */
-    #eventListeners = {}
-
-    /**
-     * Creates a new EasyflowSDK instance
-     *
-     * @param {string|Object} config - Configuration object or business ID string
-     * @param {string} config.businessId - Your Easyflow business identifier (required)
-     * @param {Object} [config.additionalOptions] - Additional configuration options
-     *
-     * @throws {SecurityError} When businessId is missing or invalid
-     * @throws {ValidationError} When configuration is invalid
-     *
-     * @example
-     * ```javascript
-     * // Using string configuration
-     * const sdk = new EasyflowSDK('your-business-id');
-     *
-     * // Using object configuration
-     * const sdk = new EasyflowSDK({
-     *   businessId: 'your-business-id',
-     *   additionalOptions: {}
-     * });
-     * ```
-     */
-    constructor(config) {
-        this.rateLimiter = new RateLimiter()
-        this.logger = new SecureLogger(
-            SECURITY_CONFIG.PRODUCTION_MODE ? 'error' : 'info'
-        )
-        if (typeof config === 'string') this.config = { businessId: config }
-        else this.config = { ...config }
-        if (!this.config.businessId)
-            throw new SecurityError('businessId is required')
-
-        Validator.validateBusinessId(this.config.businessId, 'businessId')
-
-        this.config.businessId = Sanitizer.sanitizeInput(this.config.businessId)
-        this.logger.info('EasyflowSDK initialized with security protections')
-    }
-
-    /**
-     * Initialize Easyflow SDK for low-code/no-code platforms
-     * @param {Object} config - Configuration object
-     * @returns {EasyflowIntegrationWrapper} Integration wrapper instance
-     * @static
-     */
-    static initializeForPlatform(config) {
-        return initializeEasyflow(config)
-    }
-
-    /**
-     * Create integration wrapper instance
-     * @param {Object} config - Configuration object
-     * @returns {EasyflowIntegrationWrapper} Integration wrapper instance
-     * @static
-     */
-    static createWrapper(config) {
-        return new EasyflowIntegrationWrapper(config)
-    }
-
-    /**
-     * Add event listener
-     * @param {string} event - Event name
-     * @param {Function} callback - Callback function
-     */
-    on(event, callback) {
-        if (!this.#eventListeners[event]) {
-            this.#eventListeners[event] = []
-        }
-        this.#eventListeners[event].push(callback)
-    }
-
-    /**
-     * Remove event listener
-     * @param {string} event - Event name
-     * @param {Function} callback - Callback function
-     */
-    off(event, callback) {
-        if (this.#eventListeners[event]) {
-            const index = this.#eventListeners[event].indexOf(callback)
-            if (index > -1) {
-                this.#eventListeners[event].splice(index, 1)
-            }
-        }
-    }
-
-    /**
-     * Emit event to all listeners
-     * @param {string} event - Event name
-     * @param {*} data - Event data
-     * @private
-     */
-    #emit(event, data) {
-        if (this.#eventListeners[event]) {
-            this.#eventListeners[event].forEach((callback) => {
-                try {
-                    callback(data)
-                } catch (error) {
-                    console.error(
-                        `Error in event listener for ${event}:`,
-                        error
-                    )
-                }
-            })
-        }
-    }
-
-    /**
-     * Retrieves offer information by offer ID
-     *
-     * @param {string} offerId - The unique identifier of the offer
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<Object>} Promise that resolves to the offer data
-     *
-     * @throws {ValidationError} When offerId is invalid or missing
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const offer = await sdk.getOffer('550e8400-e29b-41d4-a716-446655440000');
-     * console.log(offer.name, offer.price);
-     * ```
-     */
-    async getOffer(offerId, headers = {}) {
-        await this.rateLimiter.checkLimit('getOffer')
-        const sanitizedOfferId = Sanitizer.sanitizeInput(offerId)
-        if (!sanitizedOfferId) throw new ValidationError('Invalid offer ID')
-
-        Validator.validateOfferId(sanitizedOfferId, 'offerId')
-
-        try {
-            const result = await callSecureApi(
-                TARGETS.GET_OFFER,
-                { offerId: sanitizedOfferId },
-                headers
-            )
-            if (result.error) throwsError(new NetworkError(result.error))
-            if (!result.data)
-                throwsError(new ValidationError('Offer not found'))
-            return result.data
-        } catch (error) {
-            this.logger.error('Failed to get offer', {
-                offerId: sanitizedOfferId,
-                error: error.message,
-            })
-            throwsError(error)
-        }
-    }
-
-    /**
-     * Places an order using an existing offer
-     *
-     * @param {string} offerId - The unique identifier of the offer
-     * @param {Object} data - Order data including payment information
-     * @param {Object} data.buyer - Buyer information
-     * @param {Array<Object>} data.payments - Array of payment methods
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<string>} Promise that resolves to the order ID
-     *
-     * @throws {ValidationError} When offerId is invalid or order data is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const orderId = await sdk.placeOrder('550e8400-e29b-41d4-a716-446655440000', {
-     *     customer: {
-     *         name: 'John Doe',
-     *         email: 'john@example.com',
-     *         document: {
-     *             type: 'CPF',
-     *             number: '12345678901'
-     *         },
-     *         phone: {
-     *             areaCode: '+55',
-     *             ddd: '11',
-     *             number: '999999999',
-     *             isMobile: true
-     *         },
-     *         address: {
-     *             zipCode: '01234567',
-     *             street: 'Rua Example',
-     *             number: '123',
-     *             neighborhood: 'Centro',
-     *             city: 'São Paulo',
-     *             state: 'SP'
-     *         },
-     *         creditCard: { // card data },
-     *         pix: { // pix data },
-     *         bankBillet: { // bank billet data }
-     *     }
-     * });
-     * console.log('Order created:', orderId);
-     * ```
-     */
-    async placeOrder(offerId, data, headers = {}) {
-        await this.rateLimiter.checkLimit('placeOrder')
-        const sanitizedOfferId = Sanitizer.sanitizeInput(offerId)
-        if (!sanitizedOfferId) throw new ValidationError('Invalid offer ID')
-
-        Validator.validateOfferId(sanitizedOfferId, 'offerId')
-        Validator.validateOrderData(data)
-        if (data.buyer) Validator.validateCustomer(data.buyer, 'data.buyer')
-
-        const sanitizedData = sanitizeOrderData(data)
-        try {
-            const orderData = mapCreditCardIfNeeded(sanitizedData)
-            const offer = await this.getOffer(sanitizedOfferId, headers)
-            if (!offer?.items?.[0]?.id)
-                throwsError(
-                    new ValidationError('Invalid offer: no items found')
-                )
-            const placeOrderPayload = {
-                ...orderData,
-                businessId: this.config.businessId,
-                offerItems: [{ quantity: 1, offerItemId: offer.items[0].id }],
-            }
-            const response = await callSecureApi(
-                TARGETS.PLACE_ORDER,
-                placeOrderPayload,
-                headers
-            )
-            if (response.error) throwsError(new NetworkError(response.error))
-            if (!response.data?.orderId)
-                throwsError(
-                    new NetworkError('Invalid response: no order ID returned')
-                )
-
-            // Emit orderPlaced event
-            this.#emit('orderPlaced', {
-                orderId: response.data.orderId,
-                offerId: sanitizedOfferId,
-                data: orderData,
-            })
-
-            return response.data.orderId
-        } catch (error) {
-            this.logger.error('Failed to place order', {
-                offerId: sanitizedOfferId,
-                error: error.message,
-            })
-            throwsError(error)
-        }
-    }
-
-    /**
-     * Retrieves order information by order ID
-     *
-     * @param {string} orderId - The unique identifier of the order
-     * @param headers
-     * @returns {Promise<Object>} Promise that resolves to the order data
-     *
-     * @throws {NetworkError} When API request fails
-     *
-     * @example
-     * ```javascript
-     * const order = await sdk.getOrder('550e8400-e29b-41d4-a716-446655440000');
-     * console.log(order.status, order.total);
-     * ```
-     */
-    async getOrder(orderId, headers = {}) {
-        Validator.validateOrderId(orderId, 'orderId')
-        const response = await callSecureApi(
-            TARGETS.GET_ORDER,
-            { orderId },
-            headers
-        )
-        return (response && response.data) || null
-    }
-
-    /**
-     * Retrieves bank billet information for an order
-     *
-     * @param {string} orderId - The unique identifier of the order
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<Object|null>} Promise that resolves to bank billet data or null if not found
-     *
-     * @throws {ValidationError} When orderId is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const bankBillet = await sdk.getBankBillet('550e8400-e29b-41d4-a716-446655440000');
-     * console.log(bankBillet.code, bankBillet.expirationDate);
-     * ```
-     */
-    async getBankBillet(orderId, headers = {}) {
-        await this.rateLimiter.checkLimit('getBankBillet')
-        const sanitizedOrderId = Sanitizer.sanitizeInput(orderId)
-        if (!sanitizedOrderId) throw new ValidationError('Invalid order ID')
-        try {
-            const order = await this.getOrder(sanitizedOrderId, headers)
-            const bankBilletPayment = findPaymentByMethod(
-                order,
-                PAYMENT_METHODS.BANK_BILLET,
-                isValidBankBilletPayment
-            )
-            return bankBilletPayment?.bankBillet || null
-        } catch (error) {
-            this.logger.error('Failed to get bank billet', {
-                orderId: sanitizedOrderId,
-                error: error.message,
-            })
-            throwsError(error)
-        }
-    }
-
-    /**
-     * Processes a direct charge without using an offer
-     *
-     * @param {Object} data - Charge data including items and payment information
-     * @param {Object} data.buyer - Buyer information
-     * @param {Array<Object>} data.items - Array of items to charge
-     * @param {Array<Object>} data.payments - Array of payment methods
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<string>} Promise that resolves to the order ID
-     *
-     * @throws {ValidationError} When charge data is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const orderId = await sdk.charge({
-     *   items: [{ name: 'Product', price: 1000 }],
-     *   payments: [{
-     *     method: 'pix',
-     *     numberInstallments: 1
-     *   }]
-     * });
-     * ```
-     */
-    async charge(data, headers = {}) {
-        await this.rateLimiter.checkLimit('charge')
-        Validator.validateOrderData(data)
-        Validator.validateChargeItemsData(data.items)
-        const sanitizedData = sanitizeOrderData(data)
-        try {
-            const payload = mapCreditCardIfNeeded(sanitizedData)
-            const response = await callSecureApi(
-                TARGETS.CHARGE,
-                {
-                    ...payload,
-                    businessId: this.config.businessId,
-                },
-                headers
-            )
-            if (response.error) throwsError(new NetworkError(response.error))
-            if (!response.data?.orderId)
-                throwsError(
-                    new NetworkError('Invalid response: no order ID returned')
-                )
-
-            // Emit paymentProcessed event
-            this.#emit('paymentProcessed', {
-                orderId: response.data.orderId,
-                data: payload,
-            })
-
-            return response.data.orderId
-        } catch (error) {
-            this.logger.error('Failed to process charge', {
-                error: error.message,
-            })
-            throwsError(error)
-        }
-    }
-
-    /**
-     * Encrypts credit card data for secure transmission
-     *
-     * @param {Object} creditCard - Credit card data to encrypt
-     * @param {string} creditCard.cardNumber - Card number (13-19 digits)
-     * @param {string} creditCard.holderName - Cardholder name
-     * @param {string} creditCard.month - Expiration month (1-12)
-     * @param {string} creditCard.year - Expiration year (4 digits)
-     * @param {string} creditCard.cvv - Security code (3-4 digits)
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<string>} Promise that resolves to the encrypted token
-     *
-     * @throws {ValidationError} When credit card data is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const token = await sdk.encrypt({
-     *   cardNumber: '4111111111111111',
-     *   holderName: 'John Doe',
-     *   month: '12',
-     *   year: '2025',
-     *   cvv: '123'
-     * });
-     * ```
-     */
-    async encrypt(creditCard, headers = {}) {
-        await this.rateLimiter.checkLimit('encrypt')
-        Validator.validateCreditCardData(creditCard)
-        const sanitizedCard = Sanitizer.sanitizeCreditCard(creditCard)
-        try {
-            const response = await callSecureApi(
-                TARGETS.ENCRYPT,
-                sanitizedCard,
-                headers
-            )
-            if (response.error) throwsError(new NetworkError(response.error))
-            if (!response.data?.token)
-                throwsError(
-                    new NetworkError('Invalid response: no token returned')
-                )
-            return response.data.token
-        } catch (error) {
-            this.logger.error('Failed to encrypt credit card', {
-                error: error.message,
-            })
-            throw error
-        }
-    }
-
-    /**
-     * Retrieves PIX payment information for an order
-     *
-     * @param {string} orderId - The unique identifier of the order
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<Object|null>} Promise that resolves to PIX data or null if not found
-     *
-     * @throws {ValidationError} When orderId is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const pix = await sdk.getPix('550e8400-e29b-41d4-a716-446655440000');
-     * console.log(pix.qrCode, pix.expirationDate);
-     * ```
-     */
-    async getPix(orderId, headers = {}) {
-        await this.rateLimiter.checkLimit('getPix')
-        const sanitizedOrderId = Sanitizer.sanitizeInput(orderId)
-        if (!sanitizedOrderId) throw new ValidationError('Invalid order ID')
-        try {
-            const order = await this.getOrder(sanitizedOrderId, headers)
-            const pixPayment = findPaymentByMethod(
-                order,
-                PAYMENT_METHODS.PIX,
-                isValidPixPayment
-            )
-            return pixPayment?.pix || null
-        } catch (error) {
-            this.logger.error('Failed to get PIX data', {
-                orderId: sanitizedOrderId,
-                error: error.message,
-            })
-            throw error
-        }
-    }
-
-    /**
-     * Creates a new customer
-     *
-     * @param {Object} customer - Customer data to create
-     * @param {string} customer.name - Customer full name
-     * @param {string} customer.email - Customer email address
-     * @param {Object} customer.document - Customer legal document
-     * @param {string} customer.document.type - Document type ('CPF' or 'CNPJ')
-     * @param {string} customer.document.number - Document number
-     * @param {Object} customer.phone - Customer phone information
-     * @param {string} customer.phone.areaCode - Country area code
-     * @param {string} customer.phone.ddd - Area code
-     * @param {string} customer.phone.number - Phone number
-     * @param {boolean} customer.phone.isMobile - Whether the phone is mobile
-     * @param {Object} [customer.address] - Customer billing address
-     * @param {Object} [customer.deliveryAddress] - Customer delivery address
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<Object>} Promise that resolves to the created customer data
-     *
-     * @throws {ValidationError} When customer data is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const customer = await sdk.createCustomer({
-     *   name: 'John Doe',
-     *   email: 'john@example.com',
-     *   document: { type: 'CPF', number: '12345678901' },
-     *   phone: {
-     *     areaCode: '+55',
-     *     ddd: '11',
-     *     number: '999999999',
-     *     isMobile: true
-     *   }
-     * });
-     * ```
-     */
-    async createCustomer(customer, headers = {}) {
-        await this.rateLimiter.checkLimit('createCustomer')
-        if (!customer || typeof customer !== 'object') {
-            throwsError(new ValidationError('Customer data is required'))
-        }
-        Validator.validateCustomer(customer, 'customer')
-        const sanitizedCustomer = Sanitizer.sanitizeInput(customer)
-        const payload = {
-            ...sanitizedCustomer,
-            businessId: this.config.businessId,
-        }
-        try {
-            const response = await callSecureApi(
-                TARGETS.CREATE_CUSTOMER,
-                payload,
-                headers
-            )
-            if (response.error) throwsError(new NetworkError(response.error))
-            if (!response.data)
-                throwsError(
-                    new NetworkError(
-                        'Invalid response: no customer data returned'
-                    )
-                )
-            this.#emit('customerCreated', response.data)
-            return response.data && response.data.customer
-        } catch (error) {
-            this.logger.error('Failed to create customer', {
-                error: error.message,
-            })
-            throwsError(error)
-        }
-    }
-
-    /**
-     * Retrieves customer information by ID
-     *
-     * @param {string} id - Customer unique identifier
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<Object>} Promise that resolves to the customer data
-     *
-     * @throws {ValidationError} When customer ID is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const customer = await sdk.getCustomer('550e8400-e29b-41d4-a716-446655440000');
-     * console.log(customer.name, customer.email);
-     * ```
-     */
-    async getCustomer(id, headers = {}) {
-        await this.rateLimiter.checkLimit('getCustomer')
-        const sanitizedId = Sanitizer.sanitizeInput(id)
-        if (!sanitizedId)
-            throwsError(new ValidationError('Invalid customer ID'))
-        Validator.validateCustomerId(sanitizedId, 'customerId')
-        try {
-            const response = await callSecureApi(
-                TARGETS.GET_CUSTOMER,
-                { customerId: sanitizedId, businessId: this.config.businessId },
-                headers
-            )
-            if (response.error) throwsError(new NetworkError(response.error))
-            if (!response.data) {
-                throwsError(new ValidationError('Customer not found'))
-            }
-            return response.data && response.data.customer
-        } catch (error) {
-            this.logger.error('Failed to get customer', {
-                customerId: sanitizedId,
-                error: error.message,
-            })
-            throwsError(error)
-        }
-    }
-
-    /**
-     * Updates an existing customer
-     *
-     * @param {string} id - Customer unique identifier
-     * @param {Object} customer - Customer data to update
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<Object>} Promise that resolves to update confirmation
-     *
-     * @throws {ValidationError} When customer ID is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const result = await sdk.updateCustomer('550e8400-e29b-41d4-a716-446655440000', {
-     *   name: 'John Updated',
-     *   email: 'john.updated@example.com'
-     * });
-     * ```
-     */
-    async updateCustomer(id, customer, headers = {}) {
-        await this.rateLimiter.checkLimit('updateCustomer')
-        const sanitizedId = Sanitizer.sanitizeInput(id)
-        if (!sanitizedId)
-            throwsError(new ValidationError('Invalid customer ID'))
-        if (!customer || typeof customer !== 'object')
-            throwsError(new ValidationError('Customer update data is required'))
-
-        const sanitizedCustomer = Sanitizer.sanitizeInput(customer)
-        const payload = {
-            customerId: sanitizedId,
-            businessId: this.config.businessId,
-            ...sanitizedCustomer,
-        }
-
-        try {
-            const response = await callSecureApi(
-                TARGETS.UPDATE_CUSTOMER,
-                payload,
-                headers
-            )
-            if (response.error) throwsError(new NetworkError(response.error))
-            if (!response.data) {
-                throwsError(
-                    new NetworkError(
-                        'Invalid response: no update confirmation returned'
-                    )
-                )
-            }
-            return response.data
-        } catch (error) {
-            this.logger.error('Failed to update customer', {
-                customerId: sanitizedId,
-                error: error.message,
-            })
-            throwsError(error)
-        }
-    }
-
-    /**
-     * Adds a credit card to a customer
-     *
-     * @param {string} customerId - Customer unique identifier
-     * @param {string} creditCardToken - Encrypted credit card token
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<Object>} Promise that resolves to credit card creation confirmation
-     *
-     * @throws {ValidationError} When customer ID or credit card token is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const result = await sdk.addCreditCard('550e8400-e29b-41d4-a716-446655440000', 'encrypted-token-456');
-     * console.log('Credit card ID:', result.creditCardId);
-     * ```
-     */
-    async addCreditCard(customerId, creditCardToken, headers = {}) {
-        await this.rateLimiter.checkLimit('addCreditCard')
-        const sanitizedCustomerId = Sanitizer.sanitizeInput(customerId)
-        const sanitizedToken = Sanitizer.sanitizeInput(creditCardToken)
-
-        if (!sanitizedCustomerId)
-            throwsError(new ValidationError('Invalid customer ID'))
-        if (!sanitizedToken)
-            throwsError(new ValidationError('Invalid credit card token'))
-        Validator.validateCustomerId(sanitizedCustomerId, 'customerId')
-
-        Validator.validateCreditCardToken(sanitizedToken, 'creditCardToken')
-
-        const payload = {
-            customerId: sanitizedCustomerId,
-            businessId: this.config.businessId,
-            creditCardToken: sanitizedToken,
-        }
-
-        try {
-            const response = await callSecureApi(
-                TARGETS.ADD_CREDIT_CARD,
-                payload,
-                headers
-            )
-            if (response.error) throwsError(new NetworkError(response.error))
-            if (!response.data?.creditCardId) {
-                throwsError(
-                    new NetworkError(
-                        'Invalid response: no credit card ID returned'
-                    )
-                )
-            }
-            return response.data && response.data.creditCard
-        } catch (error) {
-            this.logger.error('Failed to add credit card', {
-                customerId: sanitizedCustomerId,
-                error: error.message,
-            })
-            throwsError(error)
-        }
-    }
-
-    /**
-     * Removes a credit card from a customer
-     *
-     * @param {string} customerId - Customer unique identifier
-     * @param {string} creditCardId - Credit card unique identifier
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<Object>} Promise that resolves to removal confirmation
-     *
-     * @throws {ValidationError} When customer ID or credit card ID is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const result = await sdk.removeCreditCard('550e8400-e29b-41d4-a716-446655440000', 'card-456');
-     * ```
-     */
-    async removeCreditCard(customerId, creditCardId, headers = {}) {
-        await this.rateLimiter.checkLimit('removeCreditCard')
-        const sanitizedCustomerId = Sanitizer.sanitizeInput(customerId)
-        const sanitizedCardId = Sanitizer.sanitizeInput(creditCardId)
-
-        if (!sanitizedCustomerId)
-            throwsError(new ValidationError('Invalid customer ID'))
-        if (!sanitizedCardId)
-            throwsError(new ValidationError('Invalid credit card ID'))
-
-        const payload = {
-            customerId: sanitizedCustomerId,
-            businessId: this.config.businessId,
-            creditCardId: sanitizedCardId,
-        }
-
-        try {
-            const response = await callSecureApi(
-                TARGETS.REMOVE_CREDIT_CARD,
-                payload,
-                headers
-            )
-            if (response.error) throwsError(new NetworkError(response.error))
-            if (!response.data) {
-                throwsError(
-                    new NetworkError(
-                        'Invalid response: no removal confirmation returned'
-                    )
-                )
-            }
-            return response.data
-        } catch (error) {
-            this.logger.error('Failed to remove credit card', {
-                customerId: sanitizedCustomerId,
-                creditCardId: sanitizedCardId,
-                error: error.message,
-            })
-            throwsError(error)
-        }
-    }
-
-    /**
-     * Retrieves credit card information by ID
-     *
-     * @param {string} customerId - Customer unique identifier
-     * @param {string} creditCardId - Credit card unique identifier
-     * @param {Object} [headers={}] - Additional HTTP headers to include in the request
-     * @returns {Promise<Object>} Promise that resolves to the credit card data
-     *
-     * @throws {ValidationError} When customer ID or credit card ID is invalid
-     * @throws {NetworkError} When API request fails
-     * @throws {SecurityError} When rate limit is exceeded
-     *
-     * @example
-     * ```javascript
-     * const creditCard = await sdk.getCreditCard('550e8400-e29b-41d4-a716-446655440000', 'card-456');
-     * console.log(creditCard.brand, creditCard.last4Numbers);
-     * ```
-     */
-    async getCreditCard(customerId, creditCardId, headers = {}) {
-        await this.rateLimiter.checkLimit('getCreditCard')
-        const sanitizedCustomerId = Sanitizer.sanitizeInput(customerId)
-        const sanitizedCardId = Sanitizer.sanitizeInput(creditCardId)
-
-        if (!sanitizedCustomerId)
-            throwsError(new ValidationError('Invalid customer ID'))
-        if (!sanitizedCardId)
-            throwsError(new ValidationError('Invalid credit card ID'))
-
-        const payload = {
-            customerId: sanitizedCustomerId,
-            businessId: this.config.businessId,
-            creditCardId: sanitizedCardId,
-        }
-
-        try {
-            const response = await callSecureApi(
-                TARGETS.GET_CREDIT_CARD,
-                payload,
-                headers
-            )
-            if (response.error) throwsError(new NetworkError(response.error))
-            if (!response.data) {
-                throwsError(new ValidationError('Credit card not found'))
-            }
-            return response.data && response.data.creditCard
-        } catch (error) {
-            this.logger.error('Failed to get credit card', {
-                customerId: sanitizedCustomerId,
-                creditCardId: sanitizedCardId,
-                error: error.message,
-            })
-            throwsError(error)
-        }
-    }
-}
-
-if (typeof window !== 'undefined') {
-    try {
-        if (SECURITY_CONFIG.PRODUCTION_MODE) {
-            if (
-                window.outerHeight - window.innerHeight > 200 ||
-                window.outerWidth - window.innerWidth > 200
-            ) {
-                throwsError(new SecurityError('Debugging detected'))
-            }
-        }
-
-        // Expose the SDK class
-        window.EasyflowSDK = EasyflowSDK
-
-        // Create a global instance with event methods for low-code platforms
-        const globalSDK = new EasyflowSDK({ businessId: 'placeholder' })
-
-        // Expose global methods for low-code platforms
-        window.easyflowSDK = {
-            // Event methods
-            on: (event, callback) => globalSDK.on(event, callback),
-            off: (event, callback) => globalSDK.off(event, callback),
-
-            // Customer methods
-            createCustomer: (data) => globalSDK.createCustomer(data),
-            getCustomer: (id) => globalSDK.getCustomer(id),
-            updateCustomer: (id, data) => globalSDK.updateCustomer(id, data),
-
-            // Payment methods
-            placeOrder: (offerId, data) => globalSDK.placeOrder(offerId, data),
-            charge: (data) => globalSDK.charge(data),
-
-            // Validation methods
-            validate: {
-                email: (email) => Validator.validateEmail(email),
-                cpf: (cpf) => Validator.validateCPF(cpf),
-                cnpj: (cnpj) => Validator.validateCNPJ(cnpj),
-                phone: (phone) => Validator.validatePhone(phone),
-                address: (address) => Validator.validateAddress(address),
-            },
-
-            // Utility methods
-            encrypt: (creditCard) => globalSDK.encrypt(creditCard),
-            getOffer: (offerId) => globalSDK.getOffer(offerId),
-            getOrder: (orderId) => globalSDK.getOrder(orderId),
-            getPix: (orderId) => globalSDK.getPix(orderId),
-            getBankBillet: (orderId) => globalSDK.getBankBillet(orderId),
-
-            // Credit card methods
-            addCreditCard: (customerId, token) =>
-                globalSDK.addCreditCard(customerId, token),
-            removeCreditCard: (customerId, cardId) =>
-                globalSDK.removeCreditCard(customerId, cardId),
-            getCreditCard: (customerId, cardId) =>
-                globalSDK.getCreditCard(customerId, cardId),
-
-            // Version info
-            version: EasyflowSDK.version,
-            PAYMENT_METHODS,
-        }
-
-        console.log('Easyflow SDK exposto globalmente como "easyflowSDK"')
-    } catch (error) {
-        console.error('Security violation detected:', error.message)
-    }
-}
-export { EasyflowSDK, PAYMENT_METHODS }