@justifi/webcomponents 6.7.3 → 6.8.0

package/dist/docs.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2025-12-26T15:42:35",
+  "timestamp": "2026-01-14T17:41:32",
   "compiler": {
     "name": "@stencil/core",
     "version": "4.38.3",
@@ -1139,7 +1139,7 @@
             }
           ],
           "optional": false,
-          "required": true,
+          "required": false,
           "getter": false,
           "setter": false
         },
@@ -7600,6 +7600,7 @@
       ],
       "dependencies": [
         "form-control-tooltip",
+        "plaid-verification",
         "bank-account-form-inputs-canada",
         "bank-account-form-inputs",
         "business-documents-on-file",
@@ -7608,6 +7609,7 @@
       "dependencyGraph": {
         "justifi-business-bank-account-form-step": [
           "form-control-tooltip",
+          "plaid-verification",
           "bank-account-form-inputs-canada",
           "bank-account-form-inputs",
           "business-documents-on-file",
@@ -15148,6 +15150,7 @@
         ],
         "justifi-business-bank-account-form-step": [
           "form-control-tooltip",
+          "plaid-verification",
           "bank-account-form-inputs-canada",
           "bank-account-form-inputs",
           "business-documents-on-file",
@@ -15502,6 +15505,7 @@
         ],
         "justifi-business-bank-account-form-step": [
           "form-control-tooltip",
+          "plaid-verification",
           "bank-account-form-inputs-canada",
           "bank-account-form-inputs",
           "business-documents-on-file",
@@ -15993,6 +15997,7 @@
         ],
         "justifi-business-bank-account-form-step": [
           "form-control-tooltip",
+          "plaid-verification",
           "bank-account-form-inputs-canada",
           "bank-account-form-inputs",
           "business-documents-on-file",
@@ -16973,8 +16978,9 @@
                 "id": "global::Promise"
               },
               "PlaidError": {
-                "location": "global",
-                "id": "global::PlaidError"
+                "location": "import",
+                "path": "../../../api/Plaid",
+                "id": "src/api/Plaid.ts::PlaidError"
               }
             },
             "return": "Promise<PlaidError>"
@@ -21485,6 +21491,136 @@
         ]
       }
     },
+    {
+      "filePath": "src/components/business-forms/payment-provisioning/plaid-verification/plaid-verification.tsx",
+      "encapsulation": "none",
+      "tag": "plaid-verification",
+      "readme": "# plaid-verification\n\n\n",
+      "docs": "",
+      "docsTags": [],
+      "usage": {},
+      "props": [
+        {
+          "name": "accountId",
+          "type": "string",
+          "complexType": {
+            "original": "string",
+            "resolved": "string",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "account-id",
+          "reflectToAttr": false,
+          "docs": "",
+          "docsTags": [],
+          "values": [
+            {
+              "type": "string"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
+        {
+          "name": "authToken",
+          "type": "string",
+          "complexType": {
+            "original": "string",
+            "resolved": "string",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "auth-token",
+          "reflectToAttr": false,
+          "docs": "",
+          "docsTags": [],
+          "values": [
+            {
+              "type": "string"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
+        {
+          "name": "businessId",
+          "type": "string",
+          "complexType": {
+            "original": "string",
+            "resolved": "string",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "business-id",
+          "reflectToAttr": false,
+          "docs": "",
+          "docsTags": [],
+          "values": [
+            {
+              "type": "string"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        }
+      ],
+      "methods": [],
+      "events": [
+        {
+          "event": "plaidVerificationError",
+          "detail": "PlaidError",
+          "bubbles": true,
+          "complexType": {
+            "original": "PlaidError",
+            "resolved": "PlaidError",
+            "references": {
+              "PlaidError": {
+                "location": "import",
+                "path": "../../../../api/Plaid",
+                "id": "src/api/Plaid.ts::PlaidError"
+              }
+            }
+          },
+          "cancelable": true,
+          "composed": true,
+          "docs": "",
+          "docsTags": []
+        },
+        {
+          "event": "plaidVerificationSuccess",
+          "detail": "{ publicToken: string; bankAccount: any; }",
+          "bubbles": true,
+          "complexType": {
+            "original": "{ publicToken: string, bankAccount: any }",
+            "resolved": "{ publicToken: string; bankAccount: any; }",
+            "references": {}
+          },
+          "cancelable": true,
+          "composed": true,
+          "docs": "",
+          "docsTags": []
+        }
+      ],
+      "listeners": [],
+      "styles": [],
+      "slots": [],
+      "parts": [],
+      "dependents": [
+        "justifi-business-bank-account-form-step"
+      ],
+      "dependencies": [],
+      "dependencyGraph": {
+        "justifi-business-bank-account-form-step": [
+          "plaid-verification"
+        ]
+      }
+    },
     {
       "filePath": "src/components/business-details/representative-details/representative-details.tsx",
       "encapsulation": "none",
@@ -22178,6 +22314,11 @@
       "docstring": "",
       "path": "src/api/index.ts"
     },
+    "src/api/Plaid.ts::PlaidError": {
+      "declaration": "export interface PlaidError {\n  code: PlaidErrorCodes;\n  message: string;\n  severity: ComponentErrorSeverity;\n  originalError?: any;\n  retryable: boolean;\n  userAction?: string;\n}",
+      "docstring": "",
+      "path": "src/api/Plaid.ts"
+    },
     "src/components/modular-checkout/ModularCheckout.ts::Hook": {
       "declaration": "(\n  data: T,\n  resolve: (data: T) => void,\n  reject: () => void,\n) => void",
       "docstring": "",

package/dist/esm/{Business-CHJTjG_5.js → Business-GgW1g7FQ.js}

@@ -496,6 +496,7 @@ class Business {
         this.website_url = business.website_url;
         this.date_of_incorporation = business.date_of_incorporation;
         this.country_of_establishment = normalizeCountry(business.country_of_establishment);
+        this.bank_account_verification = business.bank_account_verification;
     }
     get payload() {
         return {

package/dist/esm/{GooglePay-5EiPffHy.js → Plaid-CBrksnBN.js}

@@ -2,6 +2,7 @@ import { f as formatCurrency } from './utils-CDaVtz_6.js';
 import { a as DisputeStatus } from './Dispute-BH0Xfn-F.js';
 import { c as createStore } from './index-cDVGjRkU.js';
 import { P as PAYMENT_METHODS } from './index-DkoufM1t.js';
+import { C as ComponentErrorSeverity } from './ComponentError-Cjcsf8ku.js';
 
 class Completion {
     constructor(data) {
@@ -991,4 +992,54 @@ class GooglePayHelpers {
     }
 }
 
-export { ApplePayConfig as A, onChange as B, Checkout as C, onAnyChange as D, EntityDocumentType as E, getAvailablePaymentMethodTypes as F, GooglePayConfig as G, getCheckoutState as H, ICheckoutStatus as I, Payment as P, RefundReasons as R, SubAccount as S, TerminalOrderStatus as T, ICheckoutPaymentModeParam as a, TerminalOrderType as b, checkoutStore as c, ITerminalStatus as d, Payout as e, Terminal as f, PaymentStatuses as g, PaymentBalanceTransaction as h, PayoutBalanceTransaction as i, TerminalOrder as j, TerminalModel as k, RefundPayload as l, EntityDocumentStorage as m, EntityDocument as n, ApplePayHelpers as o, ApplePayPaymentRequest as p, ApplePaySessionStatus as q, ApplePayButtonStyle as r, ApplePayButtonType as s, ApplePayMerchantCapability as t, GooglePayHelpers as u, GooglePayPaymentDataRequest as v, GooglePayButtonSizeMode as w, GooglePayButtonStyle as x, GooglePayButtonType as y, GooglePayEnvironment as z };
+// Plaid-specific error codes
+var PlaidErrorCodes;
+(function (PlaidErrorCodes) {
+    PlaidErrorCodes["PLAID_SDK_LOAD_FAILED"] = "plaid-sdk-load-failed";
+    PlaidErrorCodes["PLAID_LINK_INIT_FAILED"] = "plaid-link-init-failed";
+    PlaidErrorCodes["PLAID_LINK_TOKEN_FAILED"] = "plaid-link-token-failed";
+    PlaidErrorCodes["PLAID_AUTHENTICATION_FAILED"] = "plaid-authentication-failed";
+    PlaidErrorCodes["PLAID_BANK_NOT_SUPPORTED"] = "plaid-bank-not-supported";
+    PlaidErrorCodes["PLAID_TOKEN_EXPIRED"] = "plaid-token-expired";
+    PlaidErrorCodes["PLAID_NETWORK_ERROR"] = "plaid-network-error";
+    PlaidErrorCodes["PLAID_USER_CANCELLED"] = "plaid-user-cancelled";
+    PlaidErrorCodes["PLAID_TIMEOUT"] = "plaid-timeout";
+    PlaidErrorCodes["PLAID_INVALID_CREDENTIALS"] = "plaid-invalid-credentials";
+    PlaidErrorCodes["PLAID_ACCOUNT_LOCKED"] = "plaid-account-locked";
+    PlaidErrorCodes["PLAID_MAINTENANCE"] = "plaid-maintenance";
+    PlaidErrorCodes["PLAID_RATE_LIMITED"] = "plaid-rate-limited";
+})(PlaidErrorCodes || (PlaidErrorCodes = {}));
+// Plaid error message mapping
+const PLAID_ERROR_MESSAGES = {
+    [PlaidErrorCodes.PLAID_SDK_LOAD_FAILED]: 'Unable to load Plaid. Please refresh the page and try again.',
+    [PlaidErrorCodes.PLAID_LINK_INIT_FAILED]: 'Unable to initialize bank connection. Please try again.',
+    [PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED]: 'Unable to connect to bank service. Please try again.',
+    [PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED]: 'Bank authentication failed. Please try again.',
+    [PlaidErrorCodes.PLAID_BANK_NOT_SUPPORTED]: 'Your bank is not currently supported. Please try a different payment method.',
+    [PlaidErrorCodes.PLAID_TOKEN_EXPIRED]: 'Your bank session has expired. Please reconnect your account.',
+    [PlaidErrorCodes.PLAID_NETWORK_ERROR]: 'Network connection issue. Please check your internet connection and try again.',
+    [PlaidErrorCodes.PLAID_USER_CANCELLED]: 'Bank connection was cancelled. Click to try again.',
+    [PlaidErrorCodes.PLAID_TIMEOUT]: 'Bank connection timed out. Please try again.',
+    [PlaidErrorCodes.PLAID_INVALID_CREDENTIALS]: 'Invalid bank credentials. Please check your username and password.',
+    [PlaidErrorCodes.PLAID_ACCOUNT_LOCKED]: 'Your bank account is temporarily locked. Please contact your bank.',
+    [PlaidErrorCodes.PLAID_MAINTENANCE]: 'Bank service is temporarily unavailable. Please try again later.',
+    [PlaidErrorCodes.PLAID_RATE_LIMITED]: 'Too many connection attempts. Please wait a moment and try again.',
+};
+// Plaid error severity mapping
+const PLAID_ERROR_SEVERITY = {
+    [PlaidErrorCodes.PLAID_SDK_LOAD_FAILED]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_LINK_INIT_FAILED]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_BANK_NOT_SUPPORTED]: ComponentErrorSeverity.WARNING,
+    [PlaidErrorCodes.PLAID_TOKEN_EXPIRED]: ComponentErrorSeverity.WARNING,
+    [PlaidErrorCodes.PLAID_NETWORK_ERROR]: ComponentErrorSeverity.WARNING,
+    [PlaidErrorCodes.PLAID_USER_CANCELLED]: ComponentErrorSeverity.INFO,
+    [PlaidErrorCodes.PLAID_TIMEOUT]: ComponentErrorSeverity.WARNING,
+    [PlaidErrorCodes.PLAID_INVALID_CREDENTIALS]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_ACCOUNT_LOCKED]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_MAINTENANCE]: ComponentErrorSeverity.WARNING,
+    [PlaidErrorCodes.PLAID_RATE_LIMITED]: ComponentErrorSeverity.WARNING,
+};
+
+export { ApplePayConfig as A, GooglePayButtonStyle as B, Checkout as C, GooglePayButtonType as D, EntityDocumentType as E, GooglePayEnvironment as F, GooglePayConfig as G, onChange as H, ICheckoutStatus as I, onAnyChange as J, getAvailablePaymentMethodTypes as K, getCheckoutState as L, Payment as P, RefundReasons as R, SubAccount as S, TerminalOrderStatus as T, ICheckoutPaymentModeParam as a, TerminalOrderType as b, checkoutStore as c, ITerminalStatus as d, Payout as e, Terminal as f, PaymentStatuses as g, PaymentBalanceTransaction as h, PayoutBalanceTransaction as i, TerminalOrder as j, TerminalModel as k, RefundPayload as l, PLAID_ERROR_SEVERITY as m, PLAID_ERROR_MESSAGES as n, PlaidErrorCodes as o, EntityDocumentStorage as p, EntityDocument as q, ApplePayHelpers as r, ApplePayPaymentRequest as s, ApplePaySessionStatus as t, ApplePayButtonStyle as u, ApplePayButtonType as v, ApplePayMerchantCapability as w, GooglePayHelpers as x, GooglePayPaymentDataRequest as y, GooglePayButtonSizeMode as z };

package/dist/esm/{bank-account-document-form-inputs_8.entry.js → bank-account-document-form-inputs_9.entry.js}

@@ -1,12 +1,12 @@
 import { r as registerInstance, h, H as Host, c as createEvent, g as getElement } from './index-CV0Pyo1O.js';
 import './config-state-kKn89dp1.js';
 import './dinero-HXpYMWUU.js';
-import './ComponentError-Cjcsf8ku.js';
-import { E as EntityDocumentType } from './GooglePay-5EiPffHy.js';
+import { C as ComponentErrorSeverity } from './ComponentError-Cjcsf8ku.js';
+import { E as EntityDocumentType, m as PLAID_ERROR_SEVERITY, n as PLAID_ERROR_MESSAGES, o as PlaidErrorCodes } from './Plaid-CBrksnBN.js';
 import './Pagination-CLHwhyvu.js';
-import './Business-CHJTjG_5.js';
+import './Business-GgW1g7FQ.js';
 import './Dispute-BH0Xfn-F.js';
-import { a as bankAccountTypeOptions } from './business-form-options-Bm89rMmk.js';
+import { a as bankAccountTypeOptions } from './business-form-options-DamBLV7N.js';
 import './event-types-XYgDHrVL.js';
 import { n as numberOnlyHandler } from './utils-BnjCmwMr.js';
 import { B as text, $ as card, D as heading2, ap as table, P as tableHeadCell, ay as tableCell, U as input, V as label, R as inputInvalid, S as inputDisabled, T as inputFocused, ag as buttonSecondary } from './parts-DrquDBSk.js';
@@ -14,11 +14,14 @@ import { s as snakeCaseToHumanReadable, e as formatDate, d as formatTime } from
 import { S as Skeleton } from './skeleton-D9UXuoik.js';
 import './event-types-CZfYo5-1.js';
 import { F as FormControlErrorText } from './form-control-error-text-CTQxgr7_.js';
-import { u as updateFormValues, a as updateAddressFormValues, b as updateDateOfBirthFormValues } from './input-handlers-AgwQ-yKX.js';
+import { u as updateFormValues, a as updateAddressFormValues, b as updateDateOfBirthFormValues } from './input-handlers-CzWCJ849.js';
 import { P as PHONE_MASKS, I as IDENTITY_MASKS } from './form-input-masks-CVaOFfrI.js';
-import { c as countryLabels } from './country-config-CQxaTFuP.js';
+import { c as countryLabels } from './country-config-D-9YmU94.js';
 import { c as makeGetIdentity, d as makePatchIdentity, e as makePostIdentity } from './payment-provisioning-actions-ONP8lDnV.js';
-import { I as IdentityService } from './business.service-C7smiL6_.js';
+import { I as IdentityService } from './business.service-BWm7Kqs4.js';
+import { B as Button } from './button-DMeChykB.js';
+import { S as StyledHost } from './styled-host-D6byRazK.js';
+import { P as PlaidService, p as plaidIconSvg } from './plaid-icon-wJLd-2NX.js';
 import './index-cDVGjRkU.js';
 import './index-DkoufM1t.js';
 import './utils-BeQLScSm.js';
@@ -198,4 +201,322 @@ const BusinessOwnerForm = class {
     }
 };
 
-export { BankAccountDocumentFormInputs as bank_account_document_form_inputs, BankAccountFormInputs as bank_account_form_inputs, BankAccountFormInputsCanada as bank_account_form_inputs_canada, BankAccountReadOnlyValue as bank_account_read_only_value, BusinessDocumentsOnFile as business_documents_on_file, FileInput as form_control_file, RepresentativeFormInputs as justifi_business_representative_form_inputs, BusinessOwnerForm as justifi_owner_form };
+const PlaidVerification = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.plaidVerificationSuccess = createEvent(this, "plaidVerificationSuccess", 7);
+        this.plaidVerificationError = createEvent(this, "plaidVerificationError", 7);
+        this.linkToken = null;
+        this.linkTokenId = null;
+        this.plaidLink = null;
+        this.isAuthenticating = false;
+        this.isSuccess = false;
+        this.error = null;
+        this.isLoading = false;
+        this.plaidService = new PlaidService();
+        this.abortController = null;
+        this.timeoutId = null;
+        this.initializePlaidLink = async () => {
+            try {
+                // Check if Plaid is available globally
+                if (typeof window.Plaid === 'undefined') {
+                    this.handleError({
+                        code: PlaidErrorCodes.PLAID_SDK_LOAD_FAILED,
+                        message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                        severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                        retryable: true,
+                        userAction: 'Refresh the page and try again',
+                    });
+                    return;
+                }
+                // Get link token from backend
+                await this.getLinkToken();
+                if (!this.linkToken) {
+                    this.handleError({
+                        code: PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED,
+                        message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED],
+                        severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED],
+                        retryable: true,
+                        userAction: 'Click to try again',
+                    });
+                    return;
+                }
+                // Initialize Plaid Link
+                const Plaid = window.Plaid;
+                this.plaidLink = Plaid.create({
+                    token: this.linkToken,
+                    onSuccess: this.handlePlaidSuccess,
+                    onExit: this.handlePlaidExit,
+                    onEvent: this.handlePlaidEvent,
+                    onLoad: this.handlePlaidLoad,
+                });
+            }
+            catch (error) {
+                this.handleError({
+                    code: PlaidErrorCodes.PLAID_LINK_INIT_FAILED,
+                    message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_LINK_INIT_FAILED],
+                    severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_LINK_INIT_FAILED],
+                    originalError: error,
+                    retryable: true,
+                    userAction: 'Click to try again',
+                });
+            }
+        };
+        this.getLinkToken = async () => {
+            var _a, _b, _c, _d;
+            try {
+                if (!this.authToken || !this.accountId) {
+                    this.handleError({
+                        code: PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED,
+                        message: 'Missing authentication. Please provide authToken and accountId.',
+                        severity: ComponentErrorSeverity.ERROR,
+                        retryable: false,
+                        userAction: 'Provide required props',
+                    });
+                    return;
+                }
+                // Create abort controller for timeout handling
+                this.abortController = new AbortController();
+                // Set timeout for the request
+                this.timeoutId = setTimeout(() => {
+                    var _a;
+                    (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+                }, 30000); // 30 second timeout
+                const response = await this.plaidService.getLinkTokenForVerification(this.authToken, this.businessId, this.abortController.signal);
+                // Clear timeout
+                if (this.timeoutId) {
+                    clearTimeout(this.timeoutId);
+                    this.timeoutId = null;
+                }
+                if (response.error) {
+                    const errorMessage = typeof response.error === 'string'
+                        ? response.error
+                        : response.error.message || 'Failed to get link token';
+                    throw new Error(errorMessage);
+                }
+                this.linkToken = response.data.link_token;
+                this.linkTokenId = response.data.id;
+            }
+            catch (error) {
+                // Clear timeout
+                if (this.timeoutId) {
+                    clearTimeout(this.timeoutId);
+                    this.timeoutId = null;
+                }
+                let errorCode = PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED;
+                let message = PLAID_ERROR_MESSAGES[errorCode];
+                let retryable = true;
+                // Handle specific error types
+                if (error.name === 'AbortError') {
+                    errorCode = PlaidErrorCodes.PLAID_TIMEOUT;
+                    message = PLAID_ERROR_MESSAGES[errorCode];
+                    retryable = true;
+                }
+                else if (((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('network')) || ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('fetch'))) {
+                    errorCode = PlaidErrorCodes.PLAID_NETWORK_ERROR;
+                    message = PLAID_ERROR_MESSAGES[errorCode];
+                    retryable = true;
+                }
+                else if (((_c = error.message) === null || _c === void 0 ? void 0 : _c.includes('401')) || ((_d = error.message) === null || _d === void 0 ? void 0 : _d.includes('unauthorized'))) {
+                    errorCode = PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+                    message = 'Authentication failed. Please check your credentials.';
+                    retryable = false;
+                }
+                this.handleError({
+                    code: errorCode,
+                    message: message,
+                    severity: PLAID_ERROR_SEVERITY[errorCode],
+                    originalError: error,
+                    retryable,
+                    userAction: retryable ? 'Click to try again' : 'Check your credentials',
+                });
+            }
+        };
+        this.openPlaidLink = () => {
+            if (this.plaidLink && this.linkToken) {
+                this.isAuthenticating = true;
+                this.clearError();
+                this.plaidLink.open();
+            }
+        };
+        this.handlePlaidSuccess = async (publicToken, _metadata) => {
+            var _a;
+            this.isAuthenticating = false;
+            this.isLoading = true;
+            this.clearError();
+            try {
+                // Send publicToken to backend
+                const response = await this.plaidService.postPlaidVerifiedBankAccountData(this.authToken, this.businessId, { public_token: publicToken, link_token_id: this.linkTokenId }, (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal);
+                if (response.error) {
+                    const errorMessage = typeof response.error === 'string'
+                        ? response.error
+                        : response.error.message || 'Failed to verify bank account';
+                    throw new Error(errorMessage);
+                }
+                // Success - display success message
+                this.isSuccess = true;
+                this.isLoading = false;
+                // Emit success event
+                this.plaidVerificationSuccess.emit({ publicToken, bankAccount: response.data });
+            }
+            catch (error) {
+                this.isLoading = false;
+                this.handleError({
+                    code: PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED,
+                    message: (error === null || error === void 0 ? void 0 : error.message) || 'Failed to verify bank account',
+                    severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED],
+                    originalError: error,
+                    retryable: true,
+                    userAction: 'Click to try again',
+                });
+            }
+        };
+        this.handlePlaidExit = (err, _metadata) => {
+            this.isAuthenticating = false;
+            if (err) {
+                this.handlePlaidError(err);
+            }
+        };
+        this.handlePlaidEvent = (eventName, metadata) => {
+            // Handle specific events if needed
+            switch (eventName) {
+                case 'OPEN':
+                    this.isAuthenticating = true;
+                    break;
+                case 'CLOSE':
+                    this.isAuthenticating = false;
+                    break;
+                case 'ERROR':
+                    this.handlePlaidError(metadata);
+                    break;
+            }
+        };
+        this.handlePlaidLoad = () => {
+            // Plaid Link loaded successfully
+        };
+        this.handlePlaidError = (error) => {
+            let errorCode = PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED;
+            let message = PLAID_ERROR_MESSAGES[errorCode];
+            let retryable = true;
+            let userAction = 'Click to try again';
+            // Map Plaid error codes to our error codes
+            if (error.error_code) {
+                switch (error.error_code) {
+                    case 'INVALID_CREDENTIALS':
+                        errorCode = PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = true;
+                        break;
+                    case 'ITEM_LOGIN_REQUIRED':
+                        errorCode = PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+                        message = 'Your bank requires re-authentication. Please try again.';
+                        retryable = true;
+                        break;
+                    case 'ITEM_LOCKED':
+                        errorCode = PlaidErrorCodes.PLAID_ACCOUNT_LOCKED;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = false;
+                        userAction = 'Contact your bank';
+                        break;
+                    case 'INSTITUTION_NOT_RESPONDING':
+                        errorCode = PlaidErrorCodes.PLAID_MAINTENANCE;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = true;
+                        break;
+                    case 'RATE_LIMIT_EXCEEDED':
+                        errorCode = PlaidErrorCodes.PLAID_RATE_LIMITED;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = true;
+                        break;
+                    default:
+                        if (error.error_message) {
+                            message = error.error_message;
+                        }
+                        break;
+                }
+            }
+            this.handleError({
+                code: errorCode,
+                message,
+                severity: PLAID_ERROR_SEVERITY[errorCode],
+                originalError: error,
+                retryable,
+                userAction,
+            });
+            this.isAuthenticating = false;
+        };
+        this.handleError = (plaidError) => {
+            this.error = plaidError;
+            this.isLoading = false;
+            // Emit error event for parent components
+            this.plaidVerificationError.emit(plaidError);
+            console.error('Plaid verification error:', plaidError);
+        };
+        this.clearError = () => {
+            if (this.error) {
+                this.error = null;
+            }
+        };
+    }
+    componentDidRender() {
+        if (!this.scriptRef)
+            return;
+        this.scriptRef.onload = () => {
+            this.initializePlaidLink();
+        };
+        this.scriptRef.onerror = () => {
+            this.handleError({
+                code: PlaidErrorCodes.PLAID_SDK_LOAD_FAILED,
+                message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                retryable: true,
+                userAction: 'Refresh the page and try again',
+            });
+        };
+    }
+    disconnectedCallback() {
+        // Clean up timeouts and abort controllers
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+        }
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+    }
+    render() {
+        const renderErrorState = () => {
+            if (!this.error)
+                return null;
+            const errorClass = this.error.severity === ComponentErrorSeverity.ERROR
+                ? 'text-danger'
+                : this.error.severity === ComponentErrorSeverity.WARNING
+                    ? 'text-warning'
+                    : 'text-info';
+            return (h("div", { class: `${errorClass} mt-2` }, h("small", null, this.error.message), h("br", null), this.error.userAction && (h("small", { class: "text-muted" }, this.error.userAction))));
+        };
+        const renderStatusState = () => {
+            if (this.error)
+                return null;
+            if (this.isLoading) {
+                return (h("div", { class: "text-info mt-2" }, h("small", null, "Verifying bank account...")));
+            }
+            if (this.isSuccess) {
+                return (h("div", { class: "text-success mt-2" }, h("small", null, "\u2713 Bank account verified successfully")));
+            }
+            if (this.isAuthenticating) {
+                return (h("div", { class: "text-info mt-2" }, h("small", null, "Connecting to your bank...")));
+            }
+            return null;
+        };
+        const plaidLogo = (h("img", { class: "plaid-logo-img", src: plaidIconSvg, alt: "Plaid", title: "Plaid", style: {
+                display: 'inline',
+                width: '20px',
+                height: '20px',
+                marginLeft: '5px',
+                marginTop: '-2px',
+            } }));
+        return (h(StyledHost, null, h("script", { src: "https://cdn.plaid.com/link/v2/stable/link-initialize.js", async: true, ref: (el) => (this.scriptRef = el) }), h("div", null, h("div", { class: "mb-3" }, h(Button, { variant: "secondary", type: "button", onClick: (event) => { event.preventDefault(); this.openPlaidLink(); }, disabled: this.isLoading, part: buttonSecondary }, "Link Bank Account with ", plaidLogo)), renderErrorState(), renderStatusState())));
+    }
+};
+
+export { BankAccountDocumentFormInputs as bank_account_document_form_inputs, BankAccountFormInputs as bank_account_form_inputs, BankAccountFormInputsCanada as bank_account_form_inputs_canada, BankAccountReadOnlyValue as bank_account_read_only_value, BusinessDocumentsOnFile as business_documents_on_file, FileInput as form_control_file, RepresentativeFormInputs as justifi_business_representative_form_inputs, BusinessOwnerForm as justifi_owner_form, PlaidVerification as plaid_verification };

package/dist/esm/{business-additional-questions-schema-DQb10ehS.js → business-additional-questions-schema-CQ8CuEfQ.js}

@@ -1,7 +1,7 @@
 import { c as create$3, a as create$6 } from './index.esm-IWS0494Y.js';
-import { m as makeTaxIdValidation, d as dateOfIncorporationValidation, i as industryValidation, b as businessClassificationValidation, a as doingBusinessAsValidation, p as phoneValidation, e as emailValidation, w as websiteUrlValidation, c as businessNameValidation, t as taxIdValidation, o as otherPaymentDetailsValidation, f as whenServiceReceivedValidation, r as revenueValidation, g as paymentVolumeValidation } from './schema-validations-jBrJ0mYI.js';
-import { C as CountryCode } from './Business-CHJTjG_5.js';
-import { c as countryLabels } from './country-config-CQxaTFuP.js';
+import { m as makeTaxIdValidation, d as dateOfIncorporationValidation, i as industryValidation, b as businessClassificationValidation, a as doingBusinessAsValidation, p as phoneValidation, e as emailValidation, w as websiteUrlValidation, c as businessNameValidation, t as taxIdValidation, o as otherPaymentDetailsValidation, f as whenServiceReceivedValidation, r as revenueValidation, g as paymentVolumeValidation } from './schema-validations-CfHWzMvr.js';
+import { C as CountryCode } from './Business-GgW1g7FQ.js';
+import { c as countryLabels } from './country-config-D-9YmU94.js';
 
 // Base schema (no country-specific rules for classification/tax id)
 const baseBusinessCoreInfoSchema = (allowOptionalFields) => {

package/dist/esm/{business-form-options-Bm89rMmk.js → business-form-options-DamBLV7N.js}

@@ -1,4 +1,4 @@
-import { a as BusinessClassification } from './Business-CHJTjG_5.js';
+import { a as BusinessClassification } from './Business-GgW1g7FQ.js';
 
 const businessClassificationOptions = [
     {