@justifi/webcomponents 6.0.0-rc.1 → 6.0.0-rc.11

package/dist/types/api/ApplePay.d.ts

@@ -0,0 +1,196 @@
+import { PagingInfo } from "./Pagination";
+export declare enum ApplePaySessionStatus {
+    STATUS_SUCCESS = "STATUS_SUCCESS",
+    STATUS_FAILURE = "STATUS_FAILURE"
+}
+export declare enum ApplePayButtonType {
+    PLAIN = "plain",
+    BUY = "buy",
+    SET_UP = "set-up",
+    DONATE = "donate",
+    CHECK_OUT = "check-out",
+    BOOK = "book",
+    SUBSCRIBE = "subscribe"
+}
+export declare enum ApplePayButtonStyle {
+    BLACK = "black",
+    WHITE = "white",
+    WHITE_OUTLINE = "white-outline"
+}
+export declare enum ApplePayMerchantCapability {
+    SUPPORTS_3DS = "supports3DS",
+    SUPPORTS_EMV = "supportsEMV",
+    SUPPORTS_CREDIT = "supportsCredit",
+    SUPPORTS_DEBIT = "supportsDebit"
+}
+export interface IApplePayLineItem {
+    label: string;
+    amount: string;
+    type?: 'final' | 'pending';
+}
+export interface IApplePayShippingMethod {
+    label: string;
+    amount: string;
+    identifier: string;
+    detail?: string;
+}
+export interface IApplePayPaymentRequest {
+    countryCode: string;
+    currencyCode: string;
+    merchantCapabilities: ApplePayMerchantCapability[];
+    supportedNetworks: string[];
+    total: IApplePayLineItem;
+    lineItems?: IApplePayLineItem[];
+    shippingMethods?: IApplePayShippingMethod[];
+    applicationData?: string;
+    supportedCountries?: string[];
+}
+export interface IApplePaySession {
+    canMakePayments(): boolean;
+    canMakePaymentsWithActiveCard(merchantIdentifier: string): Promise<boolean>;
+    supportsVersion(version: number): boolean;
+    begin(): void;
+    abort(): void;
+    completeMerchantValidation(merchantSession: IMerchantSession): void;
+    completePayment(result: {
+        status: ApplePaySessionStatus;
+    }): void;
+    completeShippingMethodSelection(update: any): void;
+    completePaymentMethodSelection(update: any): void;
+    onvalidatemerchant?: (event: IApplePayValidateEvent) => void;
+    onpaymentmethodselected?: (event: IApplePayMethodSelectedEvent) => void;
+    onshippingmethodselected?: () => void;
+    onpaymentauthorized?: (event: any) => void;
+    oncancel?: (event: IApplePayCancelEvent) => void;
+}
+export interface IApplePayConfig {
+    merchantIdentifier: string;
+    displayName: string;
+    initiative: string;
+    initiativeContext: string;
+    buttonType?: ApplePayButtonType;
+    buttonStyle?: ApplePayButtonStyle;
+    buttonLocale?: string;
+}
+export interface IApplePayError {
+    code: string;
+    message: string;
+}
+export interface IMerchantSession {
+    displayName: string;
+    domainName: string;
+    epochTimestamp: number;
+    expiresAt: number;
+    merchantIdentifier: string;
+    merchantSessionIdentifier: string;
+    nonce: string;
+    operationalAnalyticsIdentifier: string;
+    pspId: string;
+    retries: number;
+    signature: string;
+}
+export interface IApplePayTokenData {
+    data: string;
+    header: {
+        publicKeyHash: string;
+        ephemeralPublicKey: string;
+        transactionId: string;
+    };
+    signature: string;
+    version: string;
+}
+export interface IApplePayTokenPaymentMethod {
+    displayName: string;
+    network: string;
+    type: string;
+}
+export interface IApplePayToken {
+    paymentData: IApplePayTokenData;
+    paymentMethod: IApplePayTokenPaymentMethod;
+    transactionIdentifier: string;
+}
+export interface IApplePayValidateEvent {
+    validationURL: string;
+}
+export interface IApplePayCancelEvent {
+    sessionError?: {
+        code: 'unknown' | 'invalidMerchantSession' | 'userCancel' | string;
+        info?: string;
+    };
+}
+export interface IApplePayMethodSelectedEvent {
+    paymentMethod: IApplePayTokenPaymentMethod;
+}
+export interface IApplePayPaymentProcessRequest {
+    paymentData: IApplePayTokenData;
+    paymentMethod: IApplePayTokenPaymentMethod;
+    transactionIdentifier: string;
+    product_details?: {
+        name: string;
+        price: number;
+        description: string;
+    };
+    description?: string;
+}
+export interface IApplePayPaymentResponse {
+    id: string;
+    type: string;
+    page_info: PagingInfo | null;
+    data: {
+        account_id: string;
+        token: string;
+    };
+}
+export interface IApplePayService {
+    validateMerchant(authToken: string, accountId: string): Promise<IMerchantSession>;
+    processPayment(authToken: string, accountId: string, payload: IApplePayPaymentProcessRequest): Promise<{
+        success: boolean;
+        data: IApplePayPaymentResponse;
+    }>;
+}
+export declare class ApplePayConfig implements IApplePayConfig {
+    merchantIdentifier: string;
+    displayName: string;
+    initiative: string;
+    initiativeContext: string;
+    buttonType?: ApplePayButtonType;
+    buttonStyle?: ApplePayButtonStyle;
+    buttonLocale?: string;
+    constructor(data: IApplePayConfig);
+    get isValid(): boolean;
+}
+export declare class ApplePayPaymentRequest implements IApplePayPaymentRequest {
+    countryCode: string;
+    currencyCode: string;
+    merchantCapabilities: ApplePayMerchantCapability[];
+    supportedNetworks: string[];
+    total: IApplePayLineItem;
+    lineItems?: IApplePayLineItem[];
+    shippingMethods?: IApplePayShippingMethod[];
+    applicationData?: string;
+    supportedCountries?: string[];
+    constructor(data: IApplePayPaymentRequest);
+    get isValid(): boolean;
+}
+export declare class ApplePayHelpers {
+    static isApplePaySupported(): boolean;
+    static canMakePayments(): boolean;
+    static canMakePaymentsWithActiveCard(merchantIdentifier: string): Promise<boolean>;
+    static formatAmount(amount: number): string;
+    static parseAmount(amount: string): number;
+    static createLineItem(label: string, amount: number, type?: 'final' | 'pending'): IApplePayLineItem;
+    static getDefaultSupportedNetworks(): string[];
+    static getDefaultMerchantCapabilities(): ApplePayMerchantCapability[];
+}
+declare global {
+    interface Window {
+        ApplePaySession?: {
+            new (version: number, paymentRequest: IApplePayPaymentRequest): IApplePaySession;
+            canMakePayments(): boolean;
+            canMakePaymentsWithActiveCard(merchantIdentifier: string): Promise<boolean>;
+            supportsVersion(version: number): boolean;
+            STATUS_SUCCESS: number;
+            STATUS_FAILURE: number;
+        };
+    }
+}

package/dist/types/api/Checkout.d.ts

@@ -48,24 +48,14 @@ export interface ICheckout {
     payment_amount: number;
     payment_client_id: string;
     payment_description: string;
-    payment_methods: {
-        id: string;
-        status: string;
-        invalid_reason: null;
-        name: string;
-        brand: string;
-        acct_last_four: string;
-        month: string;
-        year: string;
-        address_line1_check: string;
-        address_postal_code_check: string;
-        bin_details: null;
-    }[];
+    payment_methods: ICheckoutPaymentMethod[];
     payment_method_group_id: string;
     payment_settings: {
         ach_payments: boolean;
         bnpl_payments: boolean;
         credit_card_payments: boolean;
+        insurance_payments?: boolean;
+        bank_account_verification?: boolean;
     };
     bnpl?: IBnpl;
     total_amount: number;
@@ -95,6 +85,8 @@ export declare class Checkout implements ICheckout {
         ach_payments: boolean;
         bnpl_payments: boolean;
         credit_card_payments: boolean;
+        insurance_payments?: boolean;
+        bank_account_verification?: boolean;
     };
     bnpl?: IBnpl;
     total_amount: number;
@@ -151,14 +143,17 @@ export interface CheckoutsQueryParams {
     status?: ICheckoutStatus;
     payment_mode?: ICheckoutPaymentMode;
 }
+export type CardBrand = 'visa' | 'mastercard' | 'american_express' | 'discover' | 'jcb' | 'diners_club' | 'unionpay';
+export type AccountType = 'checking' | 'savings';
 export interface ICheckoutPaymentMethod {
     id: string;
     type?: string;
     status: string;
     invalid_reason: null;
     name: string;
-    brand: string;
+    brand: CardBrand;
     acct_last_four: string;
+    account_type: AccountType;
     month: string;
     year: string;
     address_line1_check: string;

package/dist/types/api/Payment.d.ts

@@ -1,5 +1,5 @@
-import { DisputeStatus } from "./Dispute";
-import { IRefund } from ".";
+import { DisputeStatus } from './Dispute';
+import { IRefund } from '.';
 export declare enum CaptureStrategy {
     automatic = "automatic",
     manual = "manual"
@@ -8,7 +8,8 @@ export declare enum PaymentMethodTypes {
     card = "card",
     bankAccount = "bankAccount",
     sezzle = "sezzle",
-    saved = "saved"
+    plaid = "plaid",
+    applePay = "applePay"
 }
 export declare enum PaymentTypes {
     card = "Card",

package/dist/types/api/index.d.ts

@@ -1,7 +1,8 @@
 export * from './Api';
 export * from './ComponentEvents';
 export * from './ComponentError';
-export * from './Checkout';
+export { IBnpl, Completion, ICheckout, Checkout, ICheckoutPaymentMode, ICheckoutPaymentModeParam, ICheckoutStatus, CompletionStatuses, ICheckoutCompleteResponse, ILoadedEventResponse, CheckoutsQueryParams, ICheckoutPaymentMethod, } from './Checkout';
+export { CardBrand as CheckoutCardBrand, AccountType as BankAccountType, } from './Checkout';
 export * from './Insurance';
 export * from './Pagination';
 export * from './Payment';
@@ -16,7 +17,6 @@ export * from './Document';
 export * from './Refund';
 export * from './Business';
 export * from './Identity';
-export * from './Document';
 export * from './Dispute';
 export * from './GrossVolume';
 export { BankAccount, IBankAccount } from './BankAccount';

package/dist/types/api/services/apple-pay.service.d.ts

@@ -0,0 +1,55 @@
+import { IApplePayConfig, IApplePayPaymentRequest, IApplePayError, ApplePayConfig, IMerchantSession, IApplePayService, IApplePayPaymentProcessRequest, IApplePayPaymentResponse, IApplePayToken } from '../ApplePay';
+export declare class ApplePayService implements IApplePayService {
+    private applePayConfig?;
+    private currentSession?;
+    private currentPaymentRequest?;
+    private api;
+    /**
+     * Initialize Apple Pay configuration
+     */
+    initialize(applePayConfig: IApplePayConfig): void;
+    /**
+     * Validate merchant with Apple Pay servers via API
+     */
+    validateMerchant(authToken: string, accountId: string): Promise<IMerchantSession>;
+    /**
+     * Process Apple Pay payment via API (fixed to match original logic)
+     */
+    processPayment(authToken: string, accountId: string, payload: IApplePayPaymentProcessRequest): Promise<{
+        success: boolean;
+        data: IApplePayPaymentResponse;
+    }>;
+    /**
+     * Check if Apple Pay is available on this device/browser
+     */
+    isAvailable(): boolean;
+    /**
+     * Check if the user has an active card for the merchant
+     */
+    canMakePaymentsWithActiveCard(): Promise<boolean>;
+    /**
+     * Start Apple Pay session
+     */
+    startPaymentSession(paymentRequest: IApplePayPaymentRequest, authToken: string, accountId: string): Promise<{
+        success: boolean;
+        token?: IApplePayToken;
+        paymentMethodId?: string;
+        error?: IApplePayError;
+    }>;
+    /**
+     * Abort current Apple Pay session
+     */
+    abortPaymentSession(): void;
+    /**
+     * Setup Apple Pay session event handlers
+     */
+    private setupSessionEventHandlers;
+    /**
+     * Create a basic payment request
+     */
+    static createPaymentRequest(amount: number, label: string, countryCode?: string, currencyCode?: string): IApplePayPaymentRequest;
+    /**
+     * Get current configuration
+     */
+    getApplePayConfig(): ApplePayConfig | undefined;
+}

package/dist/types/api/services/plaid.service.d.ts

@@ -0,0 +1,12 @@
+import { IApiResponse } from '..';
+export interface ILinkTokenResponse {
+    link_token: string;
+}
+export interface IPlaidService {
+    getLinkToken(authToken: string, accountId: string, checkoutId: string, signal?: AbortSignal): Promise<IApiResponse<ILinkTokenResponse>>;
+    tokenizeBankAccount(authToken: string, accountId: string, publicToken: string, linkTokenId?: string, paymentMethodGroupId?: string, signal?: AbortSignal): Promise<IApiResponse<any>>;
+}
+export declare class PlaidService implements IPlaidService {
+    getLinkToken(authToken: string, accountId: string, checkoutId: string, signal?: AbortSignal): Promise<IApiResponse<ILinkTokenResponse>>;
+    tokenizeBankAccount(authToken: string, accountId: string, publicToken: string, linkTokenId?: string, paymentMethodGroupId?: string, signal?: AbortSignal): Promise<IApiResponse<any>>;
+}

package/dist/types/components/checkout/bank-account-form/bank-account-form.d.ts

@@ -1,6 +1,7 @@
 export declare class BankAccountForm {
     isReady: boolean;
     iframeOrigin: string;
+    tabId: string;
     private accountNumberIframeElement;
     private routingNumberIframeElement;
     componentWillLoad(): Promise<void>;

package/dist/types/components/checkout/card-form/card-form.d.ts

@@ -1,6 +1,7 @@
 export declare class CardForm {
     isReady: boolean;
     iframeOrigin: string;
+    tabId: string;
     private cardNumberIframeElement;
     private expirationMonthIframeElement;
     private expirationYearIframeElement;

package/dist/types/components/checkout/checkout.d.ts

@@ -3,18 +3,20 @@ import JustifiAnalytics from '../../api/Analytics';
 import { BillingFormFields } from './billing-form/billing-form-schema';
 import { ICheckout, ILoadedEventResponse } from '../../api';
 import { ComponentErrorEvent, ComponentSubmitEvent } from '../../api/ComponentEvents';
-import { PaymentMethodPayload } from './payment-method-payload';
+import { CheckoutChangedEventDetail, PAYMENT_METHODS } from '../modular-checkout/ModularCheckout';
 export declare class Checkout {
     analytics: JustifiAnalytics;
     modularCheckoutRef?: HTMLJustifiModularCheckoutElement;
     tokenizePaymentMethodRef?: HTMLJustifiTokenizePaymentMethodElement;
+    plaidPaymentMethodRef?: HTMLJustifiPlaidPaymentMethodElement;
+    sezzlePaymentMethodRef?: HTMLJustifiSezzlePaymentMethodElement;
+    availablePaymentMethods: PAYMENT_METHODS[];
     checkout: ICheckout;
     complete: Function;
     errorMessage: string;
     insuranceToggled: boolean;
     isSubmitting: boolean;
     serverError: string;
-    tokenizedPaymentMethod?: PaymentMethodPayload;
     authToken: string;
     checkoutId: string;
     disableBankAccount?: boolean;
@@ -31,17 +33,14 @@ export declare class Checkout {
     componentWillLoad(): void;
     disconnectedCallback(): void;
     checkoutComplete(_event: CustomEvent<any>): void;
-    checkoutError(event: CustomEvent<any>): void;
-    handleTokenizeSubmit(event: CustomEvent<{
-        response: PaymentMethodPayload;
-    }>): Promise<void>;
+    checkoutError(_event: CustomEvent<any>): void;
+    checkoutChanged(event: CustomEvent<CheckoutChangedEventDetail>): void;
     fillBillingForm(fields: BillingFormFields): Promise<void>;
     validate(): Promise<{
         isValid: boolean;
     }>;
     private updateStore;
     private submit;
-    private submitCheckoutWithToken;
     private get showPaymentTypeHeader();
     render(): any;
 }

package/dist/types/components/checkout/save-new-payment-method.d.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 export declare class SaveNewPaymentMethod {
+    label?: string;
     isChecked: boolean;
     checkboxChanged: EventEmitter<boolean>;
     private handleCheckboxChange;

package/dist/types/components/modular-checkout/ModularCheckout.d.ts

@@ -0,0 +1,31 @@
+import { ICheckoutPaymentMethod, PaymentMethodTypes } from '../../api';
+export declare enum PAYMENT_MODE {
+    ECOM = "ecom",
+    BNPL = "bnpl",
+    APPLE_PAY = "apple_pay"
+}
+export declare enum PAYMENT_METHOD_TYPES {
+    CARD = "card",
+    BANK_ACCOUNT = "bank_account",
+    APPLE_PAY = "apple_pay",
+    GOOGLE_PAY = "google_pay",
+    SEZZLE = "sezzle",
+    PLAID = "plaid"
+}
+export declare enum PAYMENT_METHODS {
+    SAVED_CARD = "saved_card",
+    NEW_CARD = "new_card",
+    SAVED_BANK_ACCOUNT = "saved_bank_account",
+    NEW_BANK_ACCOUNT = "new_bank_account",
+    APPLE_PAY = "apple_pay",
+    GOOGLE_PAY = "google_pay",
+    SEZZLE = "sezzle",
+    PLAID = "plaid"
+}
+export interface CheckoutChangedEventDetail {
+    availablePaymentMethodTypes: PAYMENT_METHODS[];
+    selectedPaymentMethod: ICheckoutPaymentMethod | {
+        type: PaymentMethodTypes;
+    };
+    savedPaymentMethods: ICheckoutPaymentMethod[];
+}

package/dist/types/components/modular-checkout/modular-checkout.d.ts

@@ -1,34 +1,42 @@
 import { EventEmitter } from "../../stencil-public-runtime";
 import JustifiAnalytics from "../../api/Analytics";
+import { ICheckoutPaymentMethod, PaymentMethodTypes } from "../../api";
 import { BillingFormFields } from "../../components";
+import { CheckoutChangedEventDetail } from "./ModularCheckout";
 export declare class ModularCheckout {
     analytics: JustifiAnalytics;
     private observer?;
     private paymentMethodFormRef?;
     private billingFormRef?;
     private insuranceFormRef?;
-    private sezzlePaymentMethodRef?;
+    private applePayRef?;
     private getCheckout;
     private completeCheckout;
+    private plaidService;
     authToken: string;
     checkoutId: string;
-    savePaymentMethod?: boolean;
     hostEl: HTMLElement;
     errorEvent: EventEmitter;
     submitEvent: EventEmitter;
-    paymentMethodChangedEvent: EventEmitter<string>;
-    savePaymentMethodChanged(newValue: boolean): void;
+    checkoutChangedEvent: EventEmitter<CheckoutChangedEventDetail>;
     connectedCallback(): void;
     componentWillLoad(): void;
     componentDidLoad(): void;
     disconnectedCallback(): void;
     private fetchCheckout;
     private updateStore;
+    private emitCheckoutChanged;
     private queryFormRefs;
+    private setupApplePayListeners;
+    private removeApplePayListeners;
+    private handleApplePayCompleted;
+    private handleApplePayError;
+    private handleApplePayCancelled;
     private tokenizePaymentMethod;
-    private getPaymentMethod;
+    setSelectedPaymentMethod(paymentMethod: ICheckoutPaymentMethod | {
+        type: PaymentMethodTypes;
+    }): Promise<void>;
     validate(): Promise<boolean>;
     submitCheckout(submitCheckoutArgs?: BillingFormFields): Promise<void>;
-    setSelectedPaymentMethod(paymentMethodId: string): Promise<void>;
     render(): any;
 }

package/dist/types/components/modular-checkout/sub-components/apple-pay-skeleton.d.ts

@@ -0,0 +1,6 @@
+import { FunctionalComponent } from "../../../stencil-public-runtime";
+interface ApplePaySkeletonProps {
+    isReady: boolean;
+}
+declare const ApplePaySkeleton: FunctionalComponent<ApplePaySkeletonProps>;
+export default ApplePaySkeleton;

package/dist/types/components/modular-checkout/sub-components/apple-pay.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+import { ApplePayButtonType, ApplePayButtonStyle, IApplePayToken } from "../../../api/ApplePay";
+export declare class ApplePay {
+    private applePayService;
+    countryCode: string;
+    merchantIdentifier: string;
+    merchantDisplayName: string;
+    initiativeContext: string;
+    buttonType: ApplePayButtonType;
+    buttonStyle: ApplePayButtonStyle;
+    disabled: boolean;
+    showSkeleton: boolean;
+    isLoading: boolean;
+    isProcessing: boolean;
+    isAvailable: boolean;
+    canMakePayments: boolean;
+    isConfigValid: boolean;
+    error: string | null;
+    applePayStarted: EventEmitter<void>;
+    applePayCompleted: EventEmitter<{
+        success: boolean;
+        token?: IApplePayToken;
+        paymentMethodId?: string;
+        error?: any;
+    }>;
+    applePayCancelled: EventEmitter<void>;
+    applePayError: EventEmitter<{
+        error: string;
+    }>;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    watchPropsChange(): void;
+    private initializeApplePay;
+    private handleApplePayClick;
+    isSupported(): Promise<boolean>;
+    getPaymentMethods(): Promise<string[]>;
+    abort(): Promise<void>;
+    render(): any;
+}

package/dist/types/components/modular-checkout/sub-components/plaid-payment-method.d.ts

@@ -0,0 +1,79 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { PaymentMethodPayload } from '../../checkout/payment-method-payload';
+import { ComponentErrorSeverity } from '../../../api/ComponentError';
+export declare enum PlaidErrorCodes {
+    PLAID_SDK_LOAD_FAILED = "plaid-sdk-load-failed",
+    PLAID_LINK_INIT_FAILED = "plaid-link-init-failed",
+    PLAID_LINK_TOKEN_FAILED = "plaid-link-token-failed",
+    PLAID_AUTHENTICATION_FAILED = "plaid-authentication-failed",
+    PLAID_BANK_NOT_SUPPORTED = "plaid-bank-not-supported",
+    PLAID_TOKEN_EXPIRED = "plaid-token-expired",
+    PLAID_NETWORK_ERROR = "plaid-network-error",
+    PLAID_USER_CANCELLED = "plaid-user-cancelled",
+    PLAID_TIMEOUT = "plaid-timeout",
+    PLAID_INVALID_CREDENTIALS = "plaid-invalid-credentials",
+    PLAID_ACCOUNT_LOCKED = "plaid-account-locked",
+    PLAID_MAINTENANCE = "plaid-maintenance",
+    PLAID_RATE_LIMITED = "plaid-rate-limited"
+}
+interface PlaidError {
+    code: PlaidErrorCodes;
+    message: string;
+    severity: ComponentErrorSeverity;
+    originalError?: any;
+    retryable: boolean;
+    userAction?: string;
+}
+export declare class PlaidPaymentMethod {
+    isAuthenticating: boolean;
+    publicToken: string | null;
+    linkToken: string | null;
+    linkTokenId: string | null;
+    error: PlaidError | null;
+    plaidLink: any;
+    isSelected: boolean;
+    retryCount: number;
+    isRetrying: boolean;
+    private scriptRef;
+    private plaidService;
+    private unsubscribeFromStore;
+    private maxRetries;
+    private retryDelay;
+    private timeoutId;
+    private abortController;
+    private hasLoggedDisabledWarning;
+    paymentMethodOptionSelected: EventEmitter;
+    plaidError: EventEmitter;
+    plaidErrorRecovered: EventEmitter;
+    onSelectionChange(newValue: boolean): void;
+    componentDidRender(): void;
+    componentWillLoad(): void;
+    waitForStoreAndInitialize: () => void;
+    resolvePaymentMethod(): Promise<PaymentMethodPayload>;
+    getPaymentToken(): Promise<string | undefined>;
+    handleSelectionClick(): Promise<void>;
+    initializePlaidLink: () => Promise<void>;
+    getLinkToken: () => Promise<void>;
+    mapApiErrorToPlaidError: (apiError: any) => PlaidErrorCodes;
+    openPlaidLink: () => void;
+    handlePlaidSuccess: (publicToken: string, _metadata: any) => void;
+    handlePlaidExit: (err: any, _metadata: any) => void;
+    handlePlaidEvent: (eventName: string, metadata: any) => void;
+    handlePlaidLoad: () => void;
+    handlePlaidError: (error: any) => void;
+    handleError: (plaidError: PlaidError) => void;
+    scheduleRetry: () => void;
+    clearError: () => void;
+    setSelected(selected: boolean): Promise<void>;
+    isCurrentlySelected(): Promise<boolean>;
+    deselect(): Promise<void>;
+    reset(): Promise<void>;
+    isReadyForAuthentication(): Promise<boolean>;
+    retry(): Promise<void>;
+    getErrorInfo(): Promise<PlaidError | null>;
+    private syncWithStore;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    render(): any;
+}
+export {};

package/dist/types/components/modular-checkout/sub-components/plaid-payment-method.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/modular-checkout/sub-components/saved-payment-methods.d.ts

@@ -1,7 +1,7 @@
 import { ICheckoutPaymentMethod } from '../../../api';
 export declare class SavedPaymentMethods {
     componentWillLoad(): void;
-    onPaymentMethodOptionClick: (paymentMethodId: string) => (e: Event) => void;
+    onPaymentMethodOptionClick: (paymentMethod: ICheckoutPaymentMethod) => (e: Event) => void;
     isAllowedPaymentMethod: (paymentMethod: ICheckoutPaymentMethod) => boolean;
     render(): any;
 }

package/dist/types/components/modular-checkout/sub-components/sezzle-payment-method.d.ts

@@ -10,7 +10,7 @@ export declare class SezzlePaymentMethod {
     paymentMethodOptionSelected: EventEmitter;
     componentDidRender(): void;
     resolvePaymentMethod(insuranceValidation: any): Promise<PaymentMethodPayload>;
-    onPaymentMethodOptionClick: (e: any) => void;
+    handleSelectionClick(): Promise<void>;
     initializeSezzleCheckout: () => void;
     render(): any;
 }