@authvia/payment-method-create 0.4.0 → 0.6.0

package/dist/components/internal/ach/AchFormSubmitBar.vue.d.ts

@@ -0,0 +1,28 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    isFormValid: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    isWorking: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    submitLabel: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    isFormValid: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    isWorking: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    submitLabel: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/internal/paymentMethodOptions/AuthviaPaymentMethodOptionsAchFlowDialogs.vue.d.ts

@@ -0,0 +1,53 @@
+import { MethodSuccessPayload } from '../../../composables/paymentMethodOptions/paymentMethodOptionsTypes';
+import { PaymentMethodBillingAddress, PaymentMethodType } from '../../../model';
+import { TermsConfig } from '../../../types';
+type __VLS_Props = {
+    showAchTypeChoice: boolean;
+    dialogAttachResolved: string | HTMLElement;
+    methodDialogClass: string;
+    achOptionsTitle: string;
+    achOnlineProp: boolean;
+    showConfirmLoader: boolean;
+    errorMessage: string;
+    authToken: string;
+    merchantId?: string;
+    customerRef?: string;
+    intent?: string;
+    achDemoMode: boolean;
+    achSubmitBtnText?: string;
+    defaultAchSubmitBtnText: string;
+    terms?: TermsConfig;
+    achBillingAddress?: PaymentMethodBillingAddress;
+    plaidData: Record<string, unknown>;
+    forgetDefault: boolean;
+    forgetHidden: boolean;
+    variant?: string;
+    color?: string;
+    borderRadius?: string;
+};
+type __VLS_PublicProps = {
+    modelValue: boolean;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+} & {
+    achClose: () => any;
+    achOptionSelect: (value: string) => any;
+    achSuccess: (value: MethodSuccessPayload | null) => any;
+    achError: (value: {
+        message: string;
+        type?: PaymentMethodType;
+    }) => any;
+    childSubmit: (value: unknown) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onAchClose?: (() => any) | undefined;
+    onAchOptionSelect?: ((value: string) => any) | undefined;
+    onAchSuccess?: ((value: MethodSuccessPayload | null) => any) | undefined;
+    onAchError?: ((value: {
+        message: string;
+        type?: PaymentMethodType;
+    }) => any) | undefined;
+    onChildSubmit?: ((value: unknown) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/internal/paymentMethodOptions/AuthviaPaymentMethodOptionsBankPlaceDialog.vue.d.ts

@@ -0,0 +1,14 @@
+type __VLS_Props = {
+    dialogAttachResolved: string | HTMLElement;
+    methodDialogClass: string;
+    achDemoMode: boolean;
+};
+type __VLS_PublicProps = {
+    modelValue: boolean;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/internal/paymentMethodOptions/AuthviaPaymentMethodOptionsPickerCard.vue.d.ts

@@ -0,0 +1,15 @@
+import { PaymentMethodConfigItem } from '../../../types';
+type PickerCardProps = {
+    show: boolean;
+    optionsCardClass: string;
+    optionsListClass: string;
+    restrictionStatements: string[] | undefined;
+    paymentMethodConfigs: PaymentMethodConfigItem[] | undefined;
+    paymentMethodOptionsContainerStyle: Record<string, string>;
+};
+declare const _default: import('vue').DefineComponent<PickerCardProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    methodClick: (type: string) => any;
+}, string, import('vue').PublicProps, Readonly<PickerCardProps> & Readonly<{
+    onMethodClick?: ((type: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/internal/paymentMethodOptions/AuthviaPaymentMethodOptionsPlaidHost.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    showPlaidOption: boolean;
+    achOnlineProp: boolean;
+    authToken: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    getPlaidData: (data: unknown) => any;
+    plaidInitialize: () => any;
+    plaidExit: () => any;
+    plaidError: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onGetPlaidData?: ((data: unknown) => any) | undefined;
+    onPlaidInitialize?: (() => any) | undefined;
+    onPlaidExit?: (() => any) | undefined;
+    onPlaidError?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/internal/paymentMethodOptions/AuthviaPaymentMethodOptionsWalletFormDialog.vue.d.ts

@@ -0,0 +1,64 @@
+import { MethodSuccessPayload } from '../../../composables/paymentMethodOptions/paymentMethodOptionsTypes';
+import { PaymentMethodBillingAddress, PaymentMethodType } from '../../../model';
+import { TermsConfig } from '../../../types';
+type __VLS_Props = {
+    activeFormType: 'creditcard' | 'paypal' | 'venmo' | null;
+    dialogAttachResolved: string | HTMLElement;
+    methodDialogClass: string;
+    creditCardSectionClass: string;
+    cardDemoMode: boolean;
+    paypalFormHeading: string;
+    venmoFormHeading: string;
+    authToken: string;
+    merchantId?: string;
+    customerRef?: string;
+    intent?: string;
+    cardNumber?: string;
+    nameOnCard?: string;
+    cardExpiration?: string;
+    cardCvv?: string;
+    cardBillingAddress?: PaymentMethodBillingAddress;
+    variant?: string;
+    color?: string;
+    borderRadius?: string;
+    cardSubmitLabel: string;
+    terms?: TermsConfig;
+    forgetDefault: boolean;
+    forgetHidden: boolean;
+    vuetifyOverrides?: string;
+    pvSettings: Record<string, unknown>;
+};
+type __VLS_PublicProps = {
+    modelValue: boolean;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+} & {
+    close: () => any;
+    childSubmit: (value: unknown) => any;
+    creditCardSuccess: (value: MethodSuccessPayload | null) => any;
+    creditCardError: (value: {
+        message: string;
+        type?: PaymentMethodType;
+    }) => any;
+    payoutSuccess: (value: MethodSuccessPayload | null) => any;
+    payoutError: (value: {
+        message: string;
+        type?: PaymentMethodType;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onChildSubmit?: ((value: unknown) => any) | undefined;
+    onCreditCardSuccess?: ((value: MethodSuccessPayload | null) => any) | undefined;
+    onCreditCardError?: ((value: {
+        message: string;
+        type?: PaymentMethodType;
+    }) => any) | undefined;
+    onPayoutSuccess?: ((value: MethodSuccessPayload | null) => any) | undefined;
+    onPayoutError?: ((value: {
+        message: string;
+        type?: PaymentMethodType;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/composables/ach/useAchFormInputModels.d.ts

@@ -0,0 +1,23 @@
+import { ComputedRef, Reactive } from 'vue';
+import { AchFieldKey, P_ACHValues } from '../../types/achForm';
+type ValidationRule = (value: unknown) => true | string;
+export type AchFormValidationApi = {
+    markFieldDirty: (field: AchFieldKey) => void;
+    getFieldRules: (field: AchFieldKey) => ValidationRule[];
+};
+/**
+ * v-model + keyboard/paste for ACH account fields.
+ */
+export declare function useAchFormInputModels(formData: Reactive<P_ACHValues>, validation: AchFormValidationApi): {
+    markFieldDirty: (field: AchFieldKey) => void;
+    getFieldRules: (field: AchFieldKey) => ValidationRule[];
+    routingNumberModel: ComputedRef<string>;
+    accountNumberModel: ComputedRef<string>;
+    nameOnAccountModel: ComputedRef<string>;
+    onDigitKeydown: (event: KeyboardEvent) => void;
+    onNameKeydown: (event: KeyboardEvent) => void;
+    onRoutingPaste: (event: ClipboardEvent) => void;
+    onAccountPaste: (event: ClipboardEvent) => void;
+    onNamePaste: (event: ClipboardEvent) => void;
+};
+export {};

package/dist/composables/ach/useAchFormReset.d.ts

@@ -0,0 +1,6 @@
+import { Reactive, Ref } from 'vue';
+import { AchFieldKey, P_ACHValues } from '../../types/achForm';
+export declare function useAchFormReset(formData: Reactive<P_ACHValues>, formRef: Ref<unknown>, addressFormRef: Ref<unknown>, dirtyFields: Record<AchFieldKey, Ref<boolean>>): {
+    clearFormData: () => void;
+    resetFormAddressData: () => void;
+};

package/dist/composables/ach/useAchFormSubmitFlow.d.ts

@@ -0,0 +1,25 @@
+import { ComputedRef, Reactive, Ref } from 'vue';
+import { UsePaymentMethodServiceReturn } from '../usePaymentMethodService';
+import { PaymentMethod } from '../../model';
+import { AchFormSubmitContextProps, P_ACHValues } from '../../types/achForm';
+type EmitFn = (event: 'submit' | 'error' | 'success', ...args: unknown[]) => void;
+export declare function useAchFormSubmitFlow(options: {
+    emit: EmitFn;
+    getSubmitProps: () => AchFormSubmitContextProps;
+    formData: Reactive<P_ACHValues>;
+    plaid: ComputedRef<Record<string, unknown> | undefined>;
+    formRef: Ref<unknown>;
+    isWorking: Ref<boolean>;
+    paymentMethodService: UsePaymentMethodServiceReturn;
+    clearFormData: () => void;
+    forgetCardValue: Ref<boolean>;
+    errorsType: Ref<{
+        other: string | undefined;
+    }>;
+    paymentMethodResponse: Ref<PaymentMethod | undefined>;
+    isPaymentMethodAdded: Ref<boolean>;
+    markRequiredFieldsDirty: (isPlaidFlow: boolean) => void;
+}): {
+    handleSubmit: () => Promise<void>;
+};
+export {};

package/dist/composables/ach/useAchFormValidation.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+import { AchFieldKey } from '../../types/achForm';
+type ValidationRule = (value: unknown) => true | string;
+export declare function useAchFormValidation(): {
+    dirtyFields: Record<AchFieldKey, Ref<boolean>>;
+    markFieldDirty: (field: AchFieldKey) => void;
+    markRequiredFieldsDirty: (isPlaidFlow: boolean) => void;
+    getFieldRules: (field: AchFieldKey) => ValidationRule[];
+};
+export {};

package/dist/composables/ach/useAuthviaPaymentMethodAddAchForm.d.ts

@@ -0,0 +1,69 @@
+import { ComputedRef, Ref } from 'vue';
+import { PaymentMethod, PaymentMethodBillingAddress } from '../../model';
+import { AuthviaPaymentMethodAddAchProps, P_ACHValues } from '../../types/achForm';
+type AchFormEmit = (event: 'submit' | 'error' | 'success', ...args: unknown[]) => void;
+/**
+ * Core state and handlers for {@link AuthviaPaymentMethodAddAch} (payment-method-add-ach).
+ */
+export declare function useAuthviaPaymentMethodAddAchForm(props: AuthviaPaymentMethodAddAchProps, emit: AchFormEmit): {
+    avwcPaymentMethodFormHooks: {
+        readonly root: "avwc-payment-method-form__root";
+        readonly optionsRoot: "avwc-payment-method-form__options-root";
+        readonly optionsCard: "avwc-payment-method-form__options-card";
+        readonly optionsList: "avwc-payment-method-form__options-list";
+        readonly methodDialog: "avwc-payment-method-form__method-dialog";
+        readonly methodRow: "avwc-payment-method-form__method-row";
+        readonly creditCardSection: "avwc-payment-method-form__credit-card-section";
+        readonly achRoot: "avwc-payment-method-form__ach-root";
+    };
+    accountTypes: {
+        savings: string;
+        checking: string;
+    };
+    fieldVariant: ComputedRef<"outlined" | "plain" | "underlined" | "filled" | "solo" | "solo-filled" | "solo-inverted">;
+    fieldVariantSafe: ComputedRef<"outlined" | "plain" | "underlined" | "filled" | "solo" | "solo-filled" | "solo-inverted">;
+    formData: P_ACHValues;
+    isWorking: Ref<boolean, boolean>;
+    isFormValid: ComputedRef<boolean>;
+    markFieldDirty: (field: import('../../types/achForm').AchFieldKey) => void;
+    getFieldRules: (field: import('../../types/achForm').AchFieldKey) => ((value: unknown) => true | string)[];
+    routingNumberModel: ComputedRef<string>;
+    accountNumberModel: ComputedRef<string>;
+    nameOnAccountModel: ComputedRef<string>;
+    onDigitKeydown: (event: KeyboardEvent) => void;
+    onNameKeydown: (event: KeyboardEvent) => void;
+    onRoutingPaste: (event: ClipboardEvent) => void;
+    onAccountPaste: (event: ClipboardEvent) => void;
+    onNamePaste: (event: ClipboardEvent) => void;
+    errorsType: Ref<{
+        other: string | undefined;
+    }, {
+        other: string | undefined;
+    }>;
+    computedSubmitLabel: ComputedRef<string>;
+    handleSubmit: () => Promise<void>;
+    isActiveTab: Ref<boolean, boolean>;
+    addButtonToggle: (value?: boolean) => void;
+    address: Ref<HTMLInputElement, HTMLInputElement>;
+    resetFormAddressData: () => void;
+    activeMerchant: ComputedRef<string | undefined>;
+    isPaymentMethodAdded: Ref<boolean, boolean>;
+    paymentMethodResponse: Ref<PaymentMethod | undefined, PaymentMethod | undefined>;
+    isAddressFieldDisabled: (fieldValue: string | undefined) => boolean;
+    azp: ComputedRef<string>;
+    handleAddressFormSubmit: (data: PaymentMethodBillingAddress) => void;
+    handleUpdateForgetCard: (value: boolean) => void;
+    addressFormRef: Ref<unknown, unknown>;
+    formRef: Ref<unknown, unknown>;
+    demoMode: ComputedRef<boolean>;
+    plaid: ComputedRef<Record<string, unknown> | undefined>;
+    billingAddress: ComputedRef<PaymentMethodBillingAddress | undefined>;
+    streetAddress: Ref<string, string>;
+    city: Ref<string, string>;
+    state: Ref<string, string>;
+    country: Ref<string, string>;
+    postalCode: Ref<string, string>;
+    googleMapsApiKey: string;
+    isAddressFormValid: (isValid: boolean) => void;
+};
+export {};

package/dist/composables/paymentMethodForm/paymentMethodFormTypes.d.ts

@@ -0,0 +1,27 @@
+import { PaymentMethodFormData } from '../../types';
+export type FormErrorPhase = 'init' | 'submit';
+export type EmittedFormError = {
+    phase: FormErrorPhase;
+    error: unknown;
+};
+/**
+ * Min subset of the parent emit API used by token validation and form handlers.
+ */
+export type AuthviaPaymentMethodFormEmit = {
+    (event: 'submit', data: PaymentMethodFormData): void;
+    (event: 'success', data: unknown): void;
+    (event: 'error', err: EmittedFormError | Record<string, unknown>): void;
+    (event: 'ready'): void;
+};
+/** Normalized object emitted on `success` when the child passes a string id or structured payload. */
+export type EmittedFormPaymentMethodSuccess = {
+    paymentMethodId: string;
+    type?: string;
+    use?: boolean;
+};
+/** What {@link usePaymentMethodFormHandlers.handlePaymentMethodSuccess} accepts from Options. */
+export type FormPaymentMethodSuccessEventPayload = string | {
+    type: string;
+    paymentMethodId: string;
+    use: boolean;
+};

package/dist/composables/paymentMethodForm/useAuthviaPaymentMethodForm.d.ts

@@ -0,0 +1,44 @@
+import { AuthviaPaymentMethodFormProps } from '../../types';
+import { AuthviaPaymentMethodFormEmit } from './paymentMethodFormTypes';
+/**
+ * Composes all setup logic for {@link AuthviaPaymentMethodForm} (theme, child props, permissions, token, handlers).
+ */
+export declare function useAuthviaPaymentMethodForm(props: AuthviaPaymentMethodFormProps, emit: AuthviaPaymentMethodFormEmit): {
+    handlePaymentMethodSubmit: (data: unknown) => void;
+    handlePaymentMethodSuccess: (data: import('./paymentMethodFormTypes').FormPaymentMethodSuccessEventPayload) => Promise<void>;
+    handlePaymentMethodFailure: (error: unknown) => void;
+    tokenValidationError: import('vue').Ref<string | null, string | null>;
+    validateToken: () => void;
+    allowedPaymentMethodTypes: import('vue').Ref<string[], string[]>;
+    cardDemoMode: import('vue').ComputedRef<boolean>;
+    achDemoMode: import('vue').ComputedRef<boolean>;
+    achOnlineFromAch: import('vue').ComputedRef<boolean>;
+    cardSubmitBtnText: import('vue').ComputedRef<string | undefined>;
+    cardNumber: import('vue').ComputedRef<string | undefined>;
+    cardExpiration: import('vue').ComputedRef<string | undefined>;
+    cardCvv: import('vue').ComputedRef<string | undefined>;
+    cardNameOnCard: import('vue').ComputedRef<string | undefined>;
+    achSubmitBtnText: import('vue').ComputedRef<string | undefined>;
+    termsConfig: import('vue').ComputedRef<import('../../types').TermsConfig | undefined>;
+    paymentMethodDisplay: import('vue').ComputedRef<import('../../types').PaymentMethodDisplayConfigMap | undefined>;
+    cardBillingAddress: import('vue').ComputedRef<import('../../model').PaymentMethodBillingAddress | undefined>;
+    achBillingAddress: import('vue').ComputedRef<import('../../model').PaymentMethodBillingAddress | undefined>;
+    forgetHidden: import('vue').ComputedRef<boolean | undefined>;
+    forgetDefault: import('vue').ComputedRef<boolean | undefined>;
+    pzSettings: import('vue').ComputedRef<Record<string, unknown>>;
+    pvSettings: import('vue').ComputedRef<Record<string, unknown>>;
+    rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    avwcPaymentMethodFormHooks: {
+        readonly root: "avwc-payment-method-form__root";
+        readonly optionsRoot: "avwc-payment-method-form__options-root";
+        readonly optionsCard: "avwc-payment-method-form__options-card";
+        readonly optionsList: "avwc-payment-method-form__options-list";
+        readonly methodDialog: "avwc-payment-method-form__method-dialog";
+        readonly methodRow: "avwc-payment-method-form__method-row";
+        readonly creditCardSection: "avwc-payment-method-form__credit-card-section";
+        readonly achRoot: "avwc-payment-method-form__ach-root";
+    };
+    cssCustomProperties: import('vue').ComputedRef<Record<string, string>>;
+    inputVariant: import('vue').ComputedRef<"outlined" | "plain" | "underlined" | "filled" | "solo" | "solo-filled" | "solo-inverted">;
+};
+export type { AuthviaPaymentMethodFormEmit } from './paymentMethodFormTypes';

package/dist/composables/paymentMethodForm/usePaymentMethodFormChildProps.d.ts

@@ -0,0 +1,25 @@
+import { ComputedRef } from 'vue';
+import { PaymentMethodBillingAddress } from '../../model';
+import { AuthviaPaymentMethodFormProps, PaymentMethodDisplayConfigMap, TermsConfig } from '../../types';
+/**
+ * Computed props passed from the form shell to {@link AuthviaPaymentMethodOptions} (and descendants).
+ */
+export declare function usePaymentMethodFormChildProps(props: AuthviaPaymentMethodFormProps): {
+    cardDemoMode: ComputedRef<boolean>;
+    achDemoMode: ComputedRef<boolean>;
+    achOnlineFromAch: ComputedRef<boolean>;
+    cardSubmitBtnText: ComputedRef<string | undefined>;
+    cardNumber: ComputedRef<string | undefined>;
+    cardExpiration: ComputedRef<string | undefined>;
+    cardCvv: ComputedRef<string | undefined>;
+    cardNameOnCard: ComputedRef<string | undefined>;
+    achSubmitBtnText: ComputedRef<string | undefined>;
+    termsConfig: ComputedRef<TermsConfig | undefined>;
+    paymentMethodDisplay: ComputedRef<PaymentMethodDisplayConfigMap | undefined>;
+    cardBillingAddress: ComputedRef<PaymentMethodBillingAddress | undefined>;
+    achBillingAddress: ComputedRef<PaymentMethodBillingAddress | undefined>;
+    forgetHidden: ComputedRef<boolean | undefined>;
+    forgetDefault: ComputedRef<boolean | undefined>;
+    pzSettings: ComputedRef<Record<string, unknown>>;
+    pvSettings: ComputedRef<Record<string, unknown>>;
+};

package/dist/composables/paymentMethodForm/usePaymentMethodFormHandlers.d.ts

@@ -0,0 +1,9 @@
+import { AuthviaPaymentMethodFormEmit, FormPaymentMethodSuccessEventPayload } from './paymentMethodFormTypes';
+/**
+ * Success / error / submit bridges from {@link AuthviaPaymentMethodOptions} to the host emit API.
+ */
+export declare function usePaymentMethodFormHandlers(emit: AuthviaPaymentMethodFormEmit): {
+    handlePaymentMethodSubmit: (data: unknown) => void;
+    handlePaymentMethodSuccess: (data: FormPaymentMethodSuccessEventPayload) => Promise<void>;
+    handlePaymentMethodFailure: (error: unknown) => void;
+};

package/dist/composables/paymentMethodForm/usePaymentMethodFormPermittedTypes.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+import { AuthviaPaymentMethodFormProps } from '../../types';
+/**
+ * `allowedPaymentMethodTypes` (picker list) and card script inject on first mount.
+ */
+export declare function usePaymentMethodFormPermittedTypes(props: AuthviaPaymentMethodFormProps): {
+    allowedPaymentMethodTypes: Ref<string[], string[]>;
+};

package/dist/composables/paymentMethodForm/usePaymentMethodFormTheme.d.ts

@@ -0,0 +1,20 @@
+import { ComputedRef, Ref } from 'vue';
+import { AuthviaPaymentMethodFormProps } from '../../types';
+/**
+ * Host root ref, BEM class hook, and CSS custom properties for the payment method form shell.
+ */
+export declare function usePaymentMethodFormTheme(props: AuthviaPaymentMethodFormProps): {
+    rootRef: Ref<HTMLElement | null, HTMLElement | null>;
+    avwcPaymentMethodFormHooks: {
+        readonly root: "avwc-payment-method-form__root";
+        readonly optionsRoot: "avwc-payment-method-form__options-root";
+        readonly optionsCard: "avwc-payment-method-form__options-card";
+        readonly optionsList: "avwc-payment-method-form__options-list";
+        readonly methodDialog: "avwc-payment-method-form__method-dialog";
+        readonly methodRow: "avwc-payment-method-form__method-row";
+        readonly creditCardSection: "avwc-payment-method-form__credit-card-section";
+        readonly achRoot: "avwc-payment-method-form__ach-root";
+    };
+    cssCustomProperties: ComputedRef<Record<string, string>>;
+    inputVariant: ComputedRef<"outlined" | "plain" | "underlined" | "filled" | "solo" | "solo-filled" | "solo-inverted">;
+};

package/dist/composables/paymentMethodForm/usePaymentMethodFormTokenValidation.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+import { AuthviaPaymentMethodFormProps } from '../../types';
+import { AuthviaPaymentMethodFormEmit } from './paymentMethodFormTypes';
+/**
+ * Token validation, error ref for gating the chooser, and `watch` on `props.token` (runs immediately).
+ */
+export declare function usePaymentMethodFormTokenValidation(props: AuthviaPaymentMethodFormProps, emit: AuthviaPaymentMethodFormEmit): {
+    tokenValidationError: Ref<string | null, string | null>;
+    validateToken: () => void;
+};

package/dist/composables/paymentMethodOptions/paymentMethodOptionsTypes.d.ts

@@ -0,0 +1,13 @@
+export type MethodSuccessPayload = {
+    id?: string;
+    use?: boolean;
+    forgetCard?: boolean;
+    data?: {
+        id?: string;
+    };
+};
+export type PazeSuccessPayload = string | {
+    id: string;
+    forgetCard?: boolean;
+} | null;
+export type PaymentMethodOptionsEmit = (event: 'on-success' | 'on-error' | 'on-submit' | 'update:forgetCard', payload?: unknown) => void;

package/dist/composables/paymentMethodOptions/useAuthviaPaymentMethodOptions.d.ts

@@ -0,0 +1,84 @@
+import { PaymentMethodOptionsProps } from '../../types/paymentMethodOptions';
+import { PaymentMethodOptionsEmit } from './paymentMethodOptionsTypes';
+/**
+ * State and handlers for the payment method options chooser (AuthviaPaymentMethodOptions).
+ * Split across {@link usePaymentMethodOptionsState}, display config, and event handlers
+ * to keep the API surface in one place without a single 500+ line function.
+ */
+export declare function useAuthviaPaymentMethodOptions(props: PaymentMethodOptionsProps, emit: PaymentMethodOptionsEmit): {
+    defaultCardSubmitBtnText: any;
+    defaultAchSubmitBtnText: any;
+    cardDemoMode: boolean | undefined;
+    achDemoMode: boolean | undefined;
+    pzSettings: Record<string, unknown> | undefined;
+    vuetifyOverrides: string | undefined;
+    closePaymentMethodForm: () => void;
+    handlePaymentMethodClick: (type: string) => void;
+    handleAchOptions: () => void;
+    handleAchClose: () => void;
+    handleAchOptionSelect: (option: string) => void;
+    handleUpdateForgetCard: (_value: boolean) => void;
+    pazeAmount: import('vue').ComputedRef<number | undefined>;
+    handlePazeSuccess: (data: import('./paymentMethodOptionsTypes').PazeSuccessPayload) => void;
+    handlePazeError: (error: {
+        message: string;
+        type?: import('../../model').PaymentMethodType;
+    }) => void;
+    handlePazeCancel: () => void;
+    handleCreditCardSuccess: (data: import('./paymentMethodOptionsTypes').MethodSuccessPayload | null) => void;
+    handleCreditCardError: (error: {
+        message: string;
+        type?: import('../../model').PaymentMethodType;
+    }) => void;
+    handlePayoutSuccess: (data: import('./paymentMethodOptionsTypes').MethodSuccessPayload | null) => void;
+    handlePayoutError: (error: {
+        message: string;
+        type?: import('../../model').PaymentMethodType;
+    }) => void;
+    handlePaymentMethodSuccess: (data: import('./paymentMethodOptionsTypes').MethodSuccessPayload | null) => void;
+    handlePaymentMethodError: (error: {
+        message: string;
+        type?: import('../../model').PaymentMethodType;
+    }) => void;
+    handleChildSubmit: (payload: unknown) => void;
+    handlePlaidResponse: (accountData: unknown) => void;
+    handlePlaidInitialize: () => void;
+    handlePlaidExit: () => void;
+    handlePlaidError: () => void;
+    restrictionStatements: import('vue').ComputedRef<string[]>;
+    paypalDescription: import('vue').ComputedRef<string>;
+    paypalFormHeading: import('vue').ComputedRef<string>;
+    venmoFormHeading: import('vue').ComputedRef<string>;
+    paymentMethodOptionsContainerStyle: import('vue').ComputedRef<Record<string, string>>;
+    paymentMethodConfigs: import('vue').ComputedRef<import('../../types').PaymentMethodConfigItem[]>;
+    dialogAttachTarget: HTMLElement | undefined;
+    optionsAttachId: string;
+    dialogAttachResolved: import('vue').ComputedRef<string | HTMLElement>;
+    showChoosePaymentMethodsModal: import('vue').Ref<boolean>;
+    showPaymentMethodForm: import('vue').Ref<boolean>;
+    activeFormType: import('vue').Ref<"creditcard" | "paypal" | "venmo" | null>;
+    showACHForm: import('vue').Ref<boolean>;
+    showACHOptions: import('vue').Ref<boolean>;
+    showPazeForm: import('vue').Ref<boolean>;
+    showPlaidOption: import('vue').Ref<boolean>;
+    showConfirmLoader: import('vue').Ref<boolean>;
+    errorMessage: import('vue').Ref<string>;
+    showAchTypeChoice: import('vue').Ref<boolean>;
+    plaidData: import('vue').Ref<Record<string, unknown>>;
+    achOptionsTitle: import('vue').ComputedRef<string>;
+    achOnlineProp: import('vue').ComputedRef<boolean>;
+    resetAchFlowState: () => void;
+    allPaymentMethodsAllowed: import('vue').ComputedRef<boolean>;
+    hasAnyPaymentMethod: import('vue').ComputedRef<boolean>;
+    avwcPaymentMethodFormHooks: {
+        readonly root: "avwc-payment-method-form__root";
+        readonly optionsRoot: "avwc-payment-method-form__options-root";
+        readonly optionsCard: "avwc-payment-method-form__options-card";
+        readonly optionsList: "avwc-payment-method-form__options-list";
+        readonly methodDialog: "avwc-payment-method-form__method-dialog";
+        readonly methodRow: "avwc-payment-method-form__method-row";
+        readonly creditCardSection: "avwc-payment-method-form__credit-card-section";
+        readonly achRoot: "avwc-payment-method-form__ach-root";
+    };
+};
+export type { PaymentMethodOptionsEmit } from './paymentMethodOptionsTypes';

package/dist/composables/paymentMethodOptions/usePaymentMethodOptionsDisplay.d.ts

@@ -0,0 +1,14 @@
+import { ComputedRef } from 'vue';
+import { PaymentMethodConfigItem } from '../../types';
+import { PaymentMethodOptionsProps } from '../../types/paymentMethodOptions';
+/**
+ * Restriction text, per-method config for the chooser, and PayPal/Venmo heading strings.
+ */
+export declare function usePaymentMethodOptionsDisplay(props: PaymentMethodOptionsProps): {
+    restrictionStatements: ComputedRef<string[]>;
+    paypalDescription: ComputedRef<string>;
+    paypalFormHeading: ComputedRef<string>;
+    venmoFormHeading: ComputedRef<string>;
+    paymentMethodOptionsContainerStyle: ComputedRef<Record<string, string>>;
+    paymentMethodConfigs: ComputedRef<PaymentMethodConfigItem[]>;
+};