@justifi/webcomponents 5.7.6 → 6.0.0-rc.2

package/dist/module/utils4.js

@@ -1,4 +1,4 @@
-import { a as ComponentErrorCodes } from './Checkout.js';
+import { a as ComponentErrorCodes } from './Refund.js';
 
 // Errors on [capital]/config/locales/en.yml
 // Add more errors as needed

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): Promise<IMerchantSession>;
+    processPayment(authToken: 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/BillingInformation.d.ts

@@ -0,0 +1,13 @@
+type IBankAccountBillingInfo = {
+    name: string;
+    address_line1: string;
+    address_line2: string;
+    address_city: string;
+    address_state: string;
+    address_postal_code: string;
+};
+type IPostalCode = {
+    address_postal_code: number;
+};
+export type IBillingInfo = IPostalCode | IBankAccountBillingInfo;
+export {};

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

@@ -89,19 +89,7 @@ export declare class Checkout implements 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;
@@ -163,4 +151,18 @@ export interface CheckoutsQueryParams {
     status?: ICheckoutStatus;
     payment_mode?: ICheckoutPaymentMode;
 }
+export interface ICheckoutPaymentMethod {
+    id: string;
+    type?: 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;
+}
 export {};

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

@@ -5,13 +5,22 @@ export declare enum ComponentErrorCodes {
     POST_ERROR = "post-error",
     UNKNOWN_ERROR = "unknown-error",
     TOKENIZE_ERROR = "tokenize-error",
+    COMPLETE_CHECKOUT_ERROR = "complete-checkout-error",
+    CHECKOUT_ALREADY_COMPLETED = "checkout-already-completed",
+    CHECKOUT_EXPIRED = "checkout-expired",
     NOT_AUTHENTICATED = "not-authenticated",
     INVALID_PARAMETER = "invalid-parameter",
     PROVISIONING_REQUESTED = "provisioning-already-requested",
-    INVALID_REFUND_AMOUNT = "invalid-refund-amount"
+    INVALID_REFUND_AMOUNT = "invalid-refund-amount",
+    VALIDATION_ERROR = "validation-error"
 }
 export declare enum ComponentErrorSeverity {
     INFO = "info",
     WARNING = "warning",
     ERROR = "error"
 }
+export declare enum ComponentErrorMessages {
+    NOT_AUTHENTICATED = "Not authenticated. Please provide a valid auth token, checkout id, and account id.",
+    CHECKOUT_ALREADY_COMPLETED = "Checkout already completed. Please create a new checkout.",
+    CHECKOUT_EXPIRED = "Checkout expired. Please create a new checkout."
+}

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

@@ -0,0 +1,21 @@
+export interface ISavedPaymentMethod {
+    payment_method_group_id?: string;
+}
+export interface IPaymentMethodCard {
+    address_postal_code: number;
+    number: string;
+    month: string;
+    year: string;
+    verification: string;
+}
+export interface IPaymentMethodBankAccount {
+    account_number: string;
+    routing_number: string;
+    account_type: string;
+    account_holder_name: string;
+    account_holder_type: string;
+    country: string;
+    currency: string;
+}
+export type ISubmitCheckoutArgs = IPaymentMethodCard | IPaymentMethodBankAccount;
+export type IPaymentMethodMetadata = ISavedPaymentMethod & ISubmitCheckoutArgs;

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

@@ -0,0 +1,65 @@
+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 apiBaseUrl;
+    private authToken?;
+    private accountId?;
+    /**
+     * Set custom API base URL
+     */
+    setApiBaseUrl(url: string): void;
+    /**
+     * Set authentication token
+     */
+    setAuthToken(authToken: string): void;
+    setAccountId(accountId: string): void;
+    /**
+     * Initialize Apple Pay configuration
+     */
+    initialize(applePayConfig: IApplePayConfig): void;
+    /**
+     * Validate merchant with Apple Pay servers via API
+     */
+    validateMerchant(authToken: string): Promise<IMerchantSession>;
+    /**
+     * Process Apple Pay payment via API (fixed to match original logic)
+     */
+    processPayment(authToken: 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): Promise<{
+        success: boolean;
+        token?: IApplePayToken;
+        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/components/checkout/billing-form/billing-form-schema.d.ts

@@ -1,9 +1,9 @@
 export interface BillingFormFields {
-    name: string;
-    address_line1: string;
+    name?: string;
+    address_line1?: string;
     address_line2?: string;
-    address_city: string;
-    address_state: string;
+    address_city?: string;
+    address_state?: string;
     address_postal_code: string;
 }
 export declare const fullBillingSchema: () => import("yup").ObjectSchema<{

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

@@ -1,31 +1,47 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 import JustifiAnalytics from '../../api/Analytics';
 import { BillingFormFields } from './billing-form/billing-form-schema';
-import { ILoadedEventResponse } from '../../api';
-import { ComponentErrorEvent } from '../../api/ComponentEvents';
+import { ICheckout, ILoadedEventResponse } from '../../api';
+import { ComponentErrorEvent, ComponentSubmitEvent } from '../../api/ComponentEvents';
+import { PaymentMethodPayload } from './payment-method-payload';
 export declare class Checkout {
+    analytics: JustifiAnalytics;
+    modularCheckoutRef?: HTMLJustifiModularCheckoutElement;
+    tokenizePaymentMethodRef?: HTMLJustifiTokenizePaymentMethodElement;
+    checkout: ICheckout;
+    complete: Function;
+    errorMessage: string;
+    insuranceToggled: boolean;
+    isSubmitting: boolean;
+    serverError: string;
+    tokenizedPaymentMethod?: PaymentMethodPayload;
     authToken: string;
     checkoutId: string;
-    disableCreditCard?: boolean;
     disableBankAccount?: boolean;
     disableBnpl?: boolean;
+    disableCreditCard?: boolean;
     disablePaymentMethodGroup?: boolean;
-    hideCardBillingForm?: boolean;
     hideBankAccountBillingForm?: boolean;
-    getCheckout: Function;
-    complete: Function;
-    errorMessage: string;
+    hideCardBillingForm?: boolean;
+    propChanged(): void;
     errorEvent: EventEmitter<ComponentErrorEvent>;
     loadedEvent: EventEmitter<ILoadedEventResponse>;
-    private checkoutCoreRef?;
-    analytics: JustifiAnalytics;
+    submitEvent: EventEmitter<ComponentSubmitEvent>;
+    connectedCallback(): void;
     componentWillLoad(): void;
     disconnectedCallback(): void;
-    private initializeGetCheckout;
-    propChanged(): void;
+    checkoutComplete(_event: CustomEvent<any>): void;
+    checkoutError(event: CustomEvent<any>): void;
+    handleTokenizeSubmit(event: CustomEvent<{
+        response: PaymentMethodPayload;
+    }>): Promise<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

@@ -2,6 +2,6 @@ import { EventEmitter } from '../../stencil-public-runtime';
 export declare class SaveNewPaymentMethod {
     isChecked: boolean;
     checkboxChanged: EventEmitter<boolean>;
-    handleCheckboxChange(_name: any, value: any): void;
+    private handleCheckboxChange;
     render(): any;
 }

package/dist/types/components/insurance/insurance-state.d.ts

@@ -5,4 +5,5 @@ declare const insuranceErrors: any;
 declare const validateInsuranceValues: () => {
     isValid: boolean;
 };
-export { insuranceValuesStore, insuranceValues, insuranceValuesOn, insuranceErrorsStore, insuranceErrors, validateInsuranceValues };
+declare const hasInsuranceValueChanged: (key: string, newValue: any) => boolean;
+export { insuranceValuesStore, insuranceValues, insuranceValuesOn, insuranceErrorsStore, insuranceErrors, validateInsuranceValues, hasInsuranceValueChanged, };

package/dist/types/components/insurance/season-interruption/season-interruption-insurance.d.ts

@@ -2,8 +2,8 @@ import { EventEmitter } from '../../../stencil-public-runtime';
 import JustifiAnalytics from '../../../api/Analytics';
 import { ComponentErrorEvent } from '../../../api/ComponentEvents';
 export declare class SeasonInterruptionInsurance {
-    authToken: string;
-    checkoutId: string;
+    authToken?: string;
+    checkoutId?: string;
     primaryIdentityFirstName: string;
     primaryIdentityLastName: string;
     primaryIdentityState: string;
@@ -18,14 +18,20 @@ export declare class SeasonInterruptionInsurance {
     getQuote: Function;
     toggleCoverage: Function;
     quote: any;
+    isLoading: boolean;
+    accepted: string | undefined;
+    insuranceUpdated: EventEmitter;
     errorEvent: EventEmitter<ComponentErrorEvent>;
-    private seasonInterruptionCoreRef?;
     analytics: JustifiAnalytics;
     validate(): Promise<{
         isValid: boolean;
     }>;
+    processHTMLContent(html: string): any;
     componentWillLoad(): void;
     disconnectedCallback(): void;
     private initializeServiceMethods;
+    fetchData(): void;
+    onChangeHandler(_name: string, value: string): void;
+    get error(): any;
     render(): any;
 }

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

@@ -0,0 +1,42 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+import JustifiAnalytics from "../../api/Analytics";
+import { BillingFormFields } from "../../components";
+export declare class ModularCheckout {
+    analytics: JustifiAnalytics;
+    private observer?;
+    private paymentMethodFormRef?;
+    private billingFormRef?;
+    private insuranceFormRef?;
+    private sezzlePaymentMethodRef?;
+    private applePayRef?;
+    private getCheckout;
+    private completeCheckout;
+    private applePayToken?;
+    authToken: string;
+    checkoutId: string;
+    savePaymentMethod?: boolean;
+    hostEl: HTMLElement;
+    errorEvent: EventEmitter;
+    submitEvent: EventEmitter;
+    paymentMethodChangedEvent: EventEmitter<string>;
+    savePaymentMethodChanged(newValue: boolean): void;
+    connectedCallback(): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    private fetchCheckout;
+    private updateStore;
+    private queryFormRefs;
+    private setupApplePayListeners;
+    private removeApplePayListeners;
+    private handleApplePayCompleted;
+    private handleApplePayError;
+    private handleApplePayCancelled;
+    private submitCheckoutWithApplePay;
+    private tokenizePaymentMethod;
+    private getPaymentMethod;
+    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,38 @@
+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;
+    apiBaseUrl: string;
+    buttonType: ApplePayButtonType;
+    buttonStyle: ApplePayButtonStyle;
+    disabled: boolean;
+    showSkeleton: boolean;
+    isLoading: boolean;
+    isProcessing: boolean;
+    isAvailable: boolean;
+    canMakePayments: boolean;
+    error: string | null;
+    applePayStarted: EventEmitter<void>;
+    applePayCompleted: EventEmitter<{
+        success: boolean;
+        token?: IApplePayToken;
+        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/{checkout/billing-form → modular-checkout/sub-components}/bank-account-billing-form-simple.d.ts

@@ -1,4 +1,4 @@
-import { BillingFormFields } from './billing-form-schema';
+import { BillingFormFields } from '../../checkout/billing-form/billing-form-schema';
 import { FormController } from '../../../ui-components/form/form';
 export declare class BankAccountBillingFormSimple {
     formController: FormController;

package/dist/types/components/modular-checkout/sub-components/bank-account-skeleton.d.ts

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

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

@@ -0,0 +1,18 @@
+import JustifiAnalytics from "../../../api/Analytics";
+export declare class BankAccountForm {
+    iframeOrigin: string;
+    isReady: boolean;
+    private accountNumberIframeElement;
+    private routingNumberIframeElement;
+    analytics: JustifiAnalytics;
+    componentWillLoad(): Promise<void>;
+    componentDidRender(): void;
+    disconnectedCallback(): void;
+    validate(): Promise<any>;
+    tokenize({ clientId, paymentMethodMetadata, account }: {
+        clientId: string;
+        paymentMethodMetadata: any;
+        account?: string;
+    }): Promise<any>;
+    render(): any;
+}

package/dist/types/components/{checkout/billing-form → modular-checkout/sub-components}/billing-form-full.d.ts

@@ -1,4 +1,4 @@
-import { BillingFormFields } from './billing-form-schema';
+import { BillingFormFields } from '../../checkout/billing-form/billing-form-schema';
 import { FormController } from '../../../ui-components/form/form';
 export declare class BillingFormFull {
     formController: FormController;
@@ -6,7 +6,6 @@ export declare class BillingFormFull {
     errors: any;
     legend?: string;
     componentWillLoad(): void;
-    componentDidLoad(): void;
     inputHandler: (name: string, value: string) => void;
     getValues(): Promise<BillingFormFields>;
     fill(fields: BillingFormFields): Promise<void>;

package/dist/types/components/{checkout/billing-form → modular-checkout/sub-components}/card-billing-form-simple.d.ts

@@ -1,4 +1,4 @@
-import { BillingFormFields } from './billing-form-schema';
+import { BillingFormFields } from '../../checkout/billing-form/billing-form-schema';
 import { FormController } from '../../../ui-components/form/form';
 export declare class CardBillingFormSimple {
     formController: FormController;

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

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

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

@@ -0,0 +1,20 @@
+import JustifiAnalytics from "../../../api/Analytics";
+export declare class JustifiCardForm {
+    isReady: boolean;
+    iframeOrigin: string;
+    private cardNumberIframeElement;
+    private expirationMonthIframeElement;
+    private expirationYearIframeElement;
+    private cvvIframeElement;
+    analytics: JustifiAnalytics;
+    componentWillLoad(): Promise<void>;
+    componentDidRender(): void;
+    disconnectedCallback(): void;
+    validate(): Promise<any>;
+    tokenize({ clientId, paymentMethodMetadata, account, }: {
+        clientId: string;
+        paymentMethodMetadata: any;
+        account?: string;
+    }): Promise<any>;
+    render(): any;
+}