@idonatedev/idonate-sdk 1.2.0-dev14 → 1.2.0-dev16

package/dist/esm/tokenize/SpreedlyTokenizer.js

@@ -66,7 +66,7 @@ export class SpreedlyTokenizer extends Tokenizer {
     }
     static create(gateway, container, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             if (container.mode !== 'bank_account') {
                 yield SpreedlyTokenizer.ensureSpreedlyLoaded();
             }
@@ -75,9 +75,9 @@ export class SpreedlyTokenizer extends Tokenizer {
                 environmentKey = config.clientConfig.spreedlyEnvironmentKey;
             }
             if (!environmentKey) {
-                environmentKey = '';
+                throw new Error('Spreedly environment key is required. Provide it via gateway.config.environmentKey or client config.');
             }
-            const tokenizer = new SpreedlyTokenizer(environmentKey, container.containerId, container.styling, container.mode || 'credit_card', container.bankCountry || 'US', container.enableTestMode || false, container.layout || 'single-line', container.responsiveBreakpoint || RESPONSIVE_BREAKPOINT);
+            const tokenizer = new SpreedlyTokenizer(environmentKey, container.containerId, container.styling, container.mode || 'credit_card', container.bankCountry || 'US', container.enableTestMode || false, container.layout || 'single-line', (_b = container.responsiveBreakpoint) !== null && _b !== void 0 ? _b : RESPONSIVE_BREAKPOINT);
             tokenizer.organizationId = config.organizationId;
             tokenizer.embedId = config.embedId;
             tokenizer.clientConfig = config.clientConfig;
@@ -158,8 +158,29 @@ export class SpreedlyTokenizer extends Tokenizer {
                     this.emit('ready');
                     resolve();
                 });
+                this.spreedly.on('paymentMethod', (token, pmData) => {
+                    const paymentToken = {
+                        token,
+                        lastFour: pmData.last_four_digits,
+                        cardType: this.normalizeCardType(pmData.card_type),
+                        paymentMethodType: 'credit_card',
+                        provider: 'spreedly',
+                    };
+                    if (this.tokenizationResolve) {
+                        const resolveTokenization = this.tokenizationResolve;
+                        this.clearTokenizationState();
+                        this.emit('tokenReady', paymentToken);
+                        resolveTokenization(paymentToken);
+                    }
+                });
                 this.spreedly.on('errors', (errors) => {
-                    this.emit('error', new TokenizationError(errors));
+                    const error = new TokenizationError(errors);
+                    this.emit('error', error);
+                    if (this.tokenizationReject) {
+                        const rejectTokenization = this.tokenizationReject;
+                        this.clearTokenizationState();
+                        rejectTokenization(error);
+                    }
                 });
                 this.spreedly.on('fieldEvent', (fieldName, eventType, activeEl, inputProperties) => {
                     this.handleFieldEvent(fieldName, eventType, inputProperties);
@@ -185,6 +206,19 @@ export class SpreedlyTokenizer extends Tokenizer {
         });
     }
     tokenizeCardInternal(cardData) {
+        if (this.tokenizationPromise) {
+            return this.tokenizationPromise;
+        }
+        const expiry = this.parseExpiry(this.expiryEl);
+        if (!expiry) {
+            return Promise.reject(new TokenizationError('Expiration date is required', 'VALIDATION_ERROR'));
+        }
+        this.tokenizationPromise = this.executeCardTokenization(cardData, expiry).finally(() => {
+            this.tokenizationPromise = undefined;
+        });
+        return this.tokenizationPromise;
+    }
+    executeCardTokenization(cardData, expiry) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             let securityFields = {};
@@ -204,42 +238,13 @@ export class SpreedlyTokenizer extends Tokenizer {
             }
             return new Promise((resolve, reject) => {
                 var _a, _b, _c, _d, _e, _f;
-                const timeout = setTimeout(() => {
-                    if (this.spreedly && this.spreedly.removeHandlers) {
-                        this.spreedly.removeHandlers();
-                    }
+                this.tokenizationResolve = resolve;
+                this.tokenizationReject = reject;
+                this.tokenizationTimeout = setTimeout(() => {
+                    this.clearTokenizationState();
                     reject(new TokenizationError('Tokenization timeout', 'TIMEOUT'));
                 }, TOKENIZE_TIMEOUT);
-                const cleanup = () => {
-                    clearTimeout(timeout);
-                    if (this.spreedly && this.spreedly.removeHandlers) {
-                        this.spreedly.removeHandlers();
-                    }
-                };
-                this.spreedly.on('paymentMethod', (token, pmData) => {
-                    cleanup();
-                    const paymentToken = {
-                        token,
-                        lastFour: pmData.last_four_digits,
-                        cardType: this.normalizeCardType(pmData.card_type),
-                        provider: 'spreedly',
-                    };
-                    this.emit('tokenReady', paymentToken);
-                    resolve(paymentToken);
-                });
-                this.spreedly.on('errors', (errors) => {
-                    cleanup();
-                    reject(new TokenizationError(errors));
-                });
-                const expiry = this.parseExpiry(this.expiryEl);
-                if (!expiry) {
-                    cleanup();
-                    reject(new TokenizationError('Expiration date is required', 'VALIDATION_ERROR'));
-                    return;
-                }
-                const expiryMonth = expiry.month;
-                const expiryYear = expiry.year;
-                this.spreedly.tokenizeCreditCard(Object.assign({ first_name: cardData.firstName, last_name: cardData.lastName, month: expiryMonth, year: expiryYear, email: cardData.email, phone_number: cardData.phone, address1: (_a = cardData.address) === null || _a === void 0 ? void 0 : _a.address1, address2: (_b = cardData.address) === null || _b === void 0 ? void 0 : _b.address2, city: (_c = cardData.address) === null || _c === void 0 ? void 0 : _c.city, state: (_d = cardData.address) === null || _d === void 0 ? void 0 : _d.state, zip: (_e = cardData.address) === null || _e === void 0 ? void 0 : _e.zip, country: (_f = cardData.address) === null || _f === void 0 ? void 0 : _f.country }, securityFields));
+                this.spreedly.tokenizeCreditCard(Object.assign({ first_name: cardData.firstName, last_name: cardData.lastName, month: expiry.month, year: expiry.year, email: cardData.email, phone_number: cardData.phone, address1: (_a = cardData.address) === null || _a === void 0 ? void 0 : _a.address1, address2: (_b = cardData.address) === null || _b === void 0 ? void 0 : _b.address2, city: (_c = cardData.address) === null || _c === void 0 ? void 0 : _c.city, state: (_d = cardData.address) === null || _d === void 0 ? void 0 : _d.state, zip: (_e = cardData.address) === null || _e === void 0 ? void 0 : _e.zip, country: (_f = cardData.address) === null || _f === void 0 ? void 0 : _f.country }, securityFields));
             });
         });
     }
@@ -432,17 +437,22 @@ export class SpreedlyTokenizer extends Tokenizer {
                     accountHolderType: accountHolderType,
                 },
             }, this.clientConfig, this.environmentKey);
-            return {
+            const paymentToken = {
                 token: result,
                 lastFour: accountNumber.slice(-4),
                 accountType: accountType,
                 paymentMethodType: 'bank_account',
                 provider: 'spreedly',
             };
+            this.emit('tokenReady', paymentToken);
+            return paymentToken;
         });
     }
     validate() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isReady) {
+                throw new Error('Tokenizer not initialized');
+            }
             if (this.mode === 'bank_account') {
                 return this.validateBankAccountInternal();
             }
@@ -630,13 +640,31 @@ export class SpreedlyTokenizer extends Tokenizer {
                 this.accountNumberEl.value = '';
             if (this.accountTypeEl)
                 this.accountTypeEl.selectedIndex = 0;
+            this.currentValidationState = {
+                isValid: false,
+                routingNumber: { isValid: false, isEmpty: true },
+                accountNumber: { isValid: false, isEmpty: true },
+            };
         }
         else {
             this.spreedly.reload();
             if (this.expiryEl) {
                 this.expiryEl.value = '';
             }
+            this.currentValidationState = {
+                isValid: false,
+                cardNumber: { isValid: false, isEmpty: true },
+                cvv: { isValid: false, isEmpty: true },
+                expiry: { isValid: false, isEmpty: true },
+            };
+        }
+        if (this.tokenizationReject) {
+            const reject = this.tokenizationReject;
+            this.clearTokenizationState();
+            reject(new TokenizationError('Tokenizer cleared', 'CLEARED'));
         }
+        this.clearTokenizationState();
+        this.emit('validation', this.currentValidationState);
     }
     focus(field) {
         if (this.mode === 'bank_account') {
@@ -727,14 +755,29 @@ export class SpreedlyTokenizer extends Tokenizer {
             }
         }
     }
+    clearTokenizationState() {
+        if (this.tokenizationTimeout) {
+            clearTimeout(this.tokenizationTimeout);
+            this.tokenizationTimeout = undefined;
+        }
+        this.tokenizationResolve = undefined;
+        this.tokenizationReject = undefined;
+    }
     destroy() {
         var _a;
+        this.markDestroyed();
         (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        if (this.tokenizationReject) {
+            const reject = this.tokenizationReject;
+            this.clearTokenizationState();
+            reject(new TokenizationError('Tokenizer destroyed', 'DESTROYED'));
+        }
         if (this.spreedly && this.spreedly.removeHandlers) {
             this.spreedly.removeHandlers();
         }
         this.eventHandlers.clear();
-        if (this.expiryEl) {
+        if (this.containerEl) {
+            this.containerEl.innerHTML = '';
         }
     }
     hasToken() {
@@ -781,15 +824,6 @@ export class SpreedlyTokenizer extends Tokenizer {
             }
             this.updateOverallValidation();
         }
-        if (eventType === 'focus') {
-            this.emit('focus', { field: fieldName });
-        }
-        else if (eventType === 'blur') {
-            this.emit('blur', { field: fieldName });
-        }
-        else if (eventType === 'input') {
-            this.emit('change', { field: fieldName });
-        }
     }
     createInternalElements() {
         const container = document.getElementById(this.containerId);
@@ -835,6 +869,10 @@ export class SpreedlyTokenizer extends Tokenizer {
                 };
                 this.updateOverallValidation();
             });
+            this.expiryEl.addEventListener('blur', () => {
+                this.validateExpiry();
+                this.updateOverallValidation();
+            });
             container.appendChild(this.expiryEl);
             const cvvDiv = createFieldContainer(this.cvvEl, '1', FIELD_FLEX.cvv.minWidth);
             cvvDiv.style.height = this.mergedStyles.input.height;
@@ -862,6 +900,10 @@ export class SpreedlyTokenizer extends Tokenizer {
                 };
                 this.updateOverallValidation();
             });
+            this.expiryEl.addEventListener('blur', () => {
+                this.validateExpiry();
+                this.updateOverallValidation();
+            });
             container.appendChild(this.expiryEl);
             const cvvDiv = createFieldContainer(this.cvvEl, FIELD_FLEX.cvv.flex, FIELD_FLEX.cvv.minWidth);
             cvvDiv.style.height = this.mergedStyles.input.height;
@@ -1024,23 +1066,31 @@ export class SpreedlyTokenizer extends Tokenizer {
         if (!this.expiryEl)
             return;
         const expiry = this.parseExpiry(this.expiryEl);
+        const isEmpty = !this.expiryEl.value;
+        let isValid = false;
         if (!expiry) {
-            this.applyErrorStyles(this.expiryEl);
-            return;
-        }
-        const month = parseInt(expiry.month, 10);
-        const year = parseInt(expiry.year, 10);
-        if (month < 1 || month > 12) {
-            this.applyErrorStyles(this.expiryEl);
-            return;
+            if (!isEmpty)
+                this.applyErrorStyles(this.expiryEl);
         }
-        const now = new Date();
-        const expiryDate = new Date(year, month - 1);
-        if (expiryDate < now) {
-            this.applyErrorStyles(this.expiryEl);
-            return;
+        else {
+            const month = parseInt(expiry.month, 10);
+            const year = parseInt(expiry.year, 10);
+            if (month < 1 || month > 12) {
+                this.applyErrorStyles(this.expiryEl);
+            }
+            else {
+                const now = new Date();
+                const expiryEndDate = new Date(year, month);
+                if (expiryEndDate <= now) {
+                    this.applyErrorStyles(this.expiryEl);
+                }
+                else {
+                    isValid = true;
+                    this.applyInputStyles(this.expiryEl, this.mergedStyles, 'middle');
+                }
+            }
         }
-        this.applyInputStyles(this.expiryEl, this.mergedStyles, 'middle');
+        this.currentValidationState.expiry = { isValid, isEmpty };
     }
     applyErrorStyles(element) {
         if (this.mergedStyles.error) {

package/dist/esm/tokenize/Tokenizer.d.ts

@@ -2,9 +2,13 @@ import { CardData, BankAccountData, PaymentData, PaymentToken, ValidationResult,
 import ConfigHandler from '../config-handler';
 export declare abstract class Tokenizer {
     protected mode: PaymentMethodMode;
-    protected eventHandlers: Map<TokenizerEvent, Set<(data?: any) => void>>;
+    protected eventHandlers: Map<string, Set<(data?: any) => void>>;
+    private focusHandlerElements;
     private _isReady;
+    private _isDestroyed;
     get isReady(): boolean;
+    get isDestroyed(): boolean;
+    protected markDestroyed(): void;
     abstract tokenize(paymentData: PaymentData): Promise<PaymentToken>;
     abstract validate(): Promise<ValidationResult>;
     abstract clear(): void;
@@ -16,7 +20,7 @@ export declare abstract class Tokenizer {
     getMode(): PaymentMethodMode;
     on(event: TokenizerEvent, handler: (data?: any) => void): void;
     off(event: TokenizerEvent, handler: (data?: any) => void): void;
-    protected emit(event: TokenizerEvent, data?: any): void;
+    protected emit(event: string, data?: any): void;
     protected isCardData(data: PaymentData): data is CardData;
     protected isBankAccountData(data: PaymentData): data is BankAccountData;
     protected normalizeCardType(providerCardType: string): CardType;

package/dist/esm/tokenize/Tokenizer.js

@@ -13,10 +13,18 @@ export class Tokenizer {
     constructor() {
         this.mode = 'credit_card';
         this.eventHandlers = new Map();
+        this.focusHandlerElements = new WeakSet();
         this._isReady = false;
+        this._isDestroyed = false;
     }
     get isReady() {
-        return this._isReady;
+        return this._isReady && !this._isDestroyed;
+    }
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
+    markDestroyed() {
+        this._isDestroyed = true;
     }
     getMode() {
         return this.mode;
@@ -82,7 +90,6 @@ export class Tokenizer {
         expiryEl.addEventListener('input', (e) => {
             const target = e.target;
             target.value = formatExpiryInput(target.value);
-            this.emit('change', { field: 'expiry' });
         });
         expiryEl.addEventListener('keypress', (e) => {
             const char = String.fromCharCode(e.which);
@@ -133,7 +140,10 @@ export class Tokenizer {
             element.style.border = inputStyles.border;
             element.style.borderRadius = inputStyles.borderRadius;
         }
-        addFocusHandlers(element, styles);
+        if (!this.focusHandlerElements.has(element)) {
+            addFocusHandlers(element, styles, position);
+            this.focusHandlerElements.add(element);
+        }
     }
     generateFieldIds(containerId) {
         return {

package/dist/esm/tokenize/gateway-utils.js

@@ -10,8 +10,9 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 export function normalizeGateway(input) {
-    if (!input)
-        return input;
+    if (!input) {
+        throw new Error('Gateway is required but received ' + String(input));
+    }
     if (input.backendName !== undefined)
         return input;
     const _a = input.config || {}, { environment_key, base_url, merchant_id } = _a, extraConfigKeys = __rest(_a, ["environment_key", "base_url", "merchant_id"]);

package/dist/esm/tokenize/index.d.ts

@@ -3,6 +3,6 @@ export { Tokenizer } from './Tokenizer';
 export { SpreedlyTokenizer } from './SpreedlyTokenizer';
 export { CardConnectTokenizer } from './CardConnectTokenizer';
 export { PayPalTokenizer, PayPalCreateOrderData } from './PayPalTokenizer';
-export { PaymentMethodType, PaymentGateway, TokenizerContainer, TokenizerStyling, CardData, PaymentData, PaymentToken, CardType, TokenizerEvent, ValidationState, ValidationResult, ValidationError, TokenizationError, } from './types';
+export { PaymentMethodType, PaymentMethodMode, PaymentGateway, TokenizerContainer, TokenizerStyling, CardData, BankAccountData, PaymentData, PaymentToken, CardType, TokenizerEvent, ValidationState, ValidationResult, ValidationError, TokenizationError, } from './types';
 export { normalizeGateway } from './gateway-utils';
 export { iats };

package/dist/esm/tokenize/spreedly-secure.js

@@ -13,6 +13,7 @@ export function fetchSpreedlySecurityArgs(config, organizationId, embedId) {
             throw new Error('Secure tokenization is not enabled');
         }
         const makeRequest = () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const response = yield fetch(`${config.embedApiBaseUrl}/spreedly/security-args`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
@@ -24,13 +25,16 @@ export function fetchSpreedlySecurityArgs(config, organizationId, embedId) {
             if (!response.ok) {
                 throw new Error(`Security args request failed: ${response.status}`);
             }
-            return response.json();
+            const data = yield response.json();
+            return (_a = data.result) !== null && _a !== void 0 ? _a : data;
         });
         try {
             return yield makeRequest();
         }
         catch (error) {
-            if (error instanceof TypeError && error.message.includes('fetch')) {
+            const isNetworkError = error instanceof TypeError && error.message.includes('fetch');
+            const isServerError = error instanceof Error && error.message.includes('failed: 5');
+            if (isNetworkError || isServerError) {
                 yield new Promise((resolve) => setTimeout(resolve, 1000));
                 return makeRequest();
             }

package/dist/esm/tokenize/tokenizer-utils.d.ts

@@ -6,7 +6,7 @@ export declare function parseExpiryDate(value: string): {
 export declare function formatExpiryInput(value: string): string;
 export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, errorMessage: string): Promise<T>;
 export declare function getConnectedBorderRadius(baseRadius: string, position: 'left' | 'middle' | 'right', isConnected: boolean): string;
-export declare function addFocusHandlers(element: HTMLElement, styles: TokenizerStylingComplete, onFocus?: () => void, onBlur?: () => void): void;
+export declare function addFocusHandlers(element: HTMLElement, styles: TokenizerStylingComplete, position?: 'left' | 'middle' | 'right', onFocus?: () => void, onBlur?: () => void): void;
 export declare function createFieldContainer(id: string, flex: string, minWidth?: string, maxWidth?: string): HTMLDivElement;
 export declare function createInputElement(id: string, type: string, placeholder: string, maxLength?: number): HTMLInputElement;
 export declare function validateRoutingNumber(routingNumber: string): boolean;

package/dist/esm/tokenize/tokenizer-utils.js

@@ -39,7 +39,7 @@ export function getConnectedBorderRadius(baseRadius, position, isConnected) {
             return baseRadius;
     }
 }
-export function addFocusHandlers(element, styles, onFocus, onBlur) {
+export function addFocusHandlers(element, styles, position, onFocus, onBlur) {
     element.addEventListener('focus', () => {
         if (styles.focus) {
             Object.assign(element.style, styles.focus);
@@ -47,9 +47,30 @@ export function addFocusHandlers(element, styles, onFocus, onBlur) {
         onFocus === null || onFocus === void 0 ? void 0 : onFocus();
     });
     element.addEventListener('blur', () => {
-        element.style.border = styles.input.border;
-        element.style.outline = 'none';
-        element.style.boxShadow = 'none';
+        const isConnected = styles.container.gap === '0';
+        if (isConnected && position) {
+            element.style.borderTop = styles.input.border;
+            element.style.borderBottom = styles.input.border;
+            switch (position) {
+                case 'left':
+                    element.style.borderLeft = styles.input.border;
+                    element.style.borderRight = 'none';
+                    break;
+                case 'middle':
+                    element.style.borderLeft = styles.input.border;
+                    element.style.borderRight = 'none';
+                    break;
+                case 'right':
+                    element.style.borderLeft = styles.input.border;
+                    element.style.borderRight = styles.input.border;
+                    break;
+            }
+        }
+        else {
+            element.style.border = styles.input.border;
+        }
+        element.style.outline = '';
+        element.style.boxShadow = '';
         onBlur === null || onBlur === void 0 ? void 0 : onBlur();
     });
 }

package/dist/esm/tokenize/types.d.ts

@@ -1,5 +1,5 @@
 export type PaymentMethodType = 'credit_card' | 'bank_account' | 'paypal' | 'apple_pay' | 'google_pay';
-export type PaymentMethodMode = 'credit_card' | 'bank_account';
+export type PaymentMethodMode = 'credit_card' | 'bank_account' | 'paypal';
 export interface PaymentGateway {
     id: string;
     backendName: string;
@@ -106,9 +106,10 @@ export interface PaymentToken {
     paymentTransactionId?: string;
 }
 export type CardType = 'visa' | 'mastercard' | 'amex' | 'discover' | 'diners' | 'jcb' | 'unknown';
-export type TokenizerEvent = 'ready' | 'focus' | 'blur' | 'change' | 'validation' | 'cardTypeChange' | 'error' | 'tokenization' | 'tokenReady';
+export type TokenizerEvent = 'ready' | 'validation' | 'cardTypeChange' | 'error' | 'tokenReady';
 export interface ValidationState {
     isValid: boolean;
+    hasToken?: boolean;
     cardNumber?: {
         isValid: boolean;
         isEmpty: boolean;

package/dist/esm/typeAdapters.js

@@ -102,16 +102,18 @@ export function buildCashPaymentPayload(organizationId, input) {
             utmFields.utm_term = input.utm.term;
         }
     }
+    let remainingMeta = input.customerMeta
+        ? Object.assign({}, input.customerMeta) : {};
     if (input.customerMeta) {
         [1, 2, 3, 4, 5].forEach((customNoteIndex) => {
             const key = `custom_note_${customNoteIndex}`;
-            if (input.customerMeta[key]) {
-                donationOptions[key] = input.customerMeta[key];
-                delete input.customerMeta[key];
+            if (remainingMeta[key]) {
+                donationOptions[key] = remainingMeta[key];
+                delete remainingMeta[key];
             }
         });
     }
-    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, donationOptions), billingAddress), billingContact), payment), utmFields), { customer_meta: input.customerMeta || {}, recaptcha_token: input.recaptchaToken, recaptcha_type: input.recaptchaType });
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, donationOptions), billingAddress), billingContact), payment), utmFields), { customer_meta: remainingMeta, recaptcha_token: input.recaptchaToken, recaptcha_type: input.recaptchaType });
 }
 export function buildDonationResult(response) {
     let campaign;

package/dist/tokenize/CardConnectTokenizer.d.ts

@@ -16,10 +16,13 @@ export declare class CardConnectTokenizer extends Tokenizer {
     private accountTypeEl?;
     private enableTestMode;
     private cachedTokenResult?;
+    private acceptAutoToken;
     private tokenizationPromise?;
     private tokenizationResolve?;
     private tokenizationReject?;
     private currentCardType?;
+    private tokenizationTimeout?;
+    private mergedStyles?;
     private constructor();
     static create(gateway: PaymentGateway, container: TokenizerContainer, config: {
         organizationId: string;
@@ -29,6 +32,8 @@ export declare class CardConnectTokenizer extends Tokenizer {
     private createInternalElements;
     private createCreditCardFields;
     private createBankAccountFields;
+    private addBankAccountValidationListeners;
+    private updateBankAccountValidation;
     private init;
     tokenize(paymentData: PaymentData): Promise<PaymentToken>;
     private tokenizeCardInternal;
@@ -47,5 +52,5 @@ export declare class CardConnectTokenizer extends Tokenizer {
     private static generateIframeUrl;
     private static createIframe;
     private static generateCardConnectCss;
-    static tokenizeBankAccount(routingNumber: string, accountNumber: string, config: ConfigHandler): Promise<TokenizeCardConnectBankAccountResult>;
+    static tokenizeBankAccount(routingNumber: string, accountNumber: string, configOrBaseUrl: ConfigHandler | string): Promise<TokenizeCardConnectBankAccountResult>;
 }