@rebilly/framepay 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,1790 @@
+/// <reference types="applepayjs" />
+/// <reference types="googlepay" />
+
+import type { coreComponents } from 'rebilly-js-sdk/types';
+import type Emitter from 'component-emitter';
+import Postmate from 'popostmate';
+import type { reportsComponents } from 'rebilly-js-sdk/types';
+
+export declare interface AddressData {
+    countryCode?: string;
+}
+
+export declare type AllPossibleRuntimePluginReturnTypes = {
+    leadSources?: LeadSourceResult;
+};
+
+export declare class ApplePay extends PaymentMethod {
+    applePayValidationRequest: DigitalWalletValidationRequest;
+    ApplePayMarkIcon: string;
+    constructor(framepayInstance: FramePay, applePayValidationRequest: DigitalWalletValidationRequest);
+    mount(target: HTMLElement | string): ApplePayElement;
+}
+
+export declare interface ApplePayConfig {
+    buttonColor?: string;
+    buttonLanguage?: string;
+    buttonType?: string;
+}
+
+export declare class ApplePayElement {
+    #private;
+    htmlTargetElement: HTMLElement;
+    element: {
+        name: string;
+    };
+    controllerFrame: ControllerFrame;
+    applePayButton: HTMLButtonElement;
+    applePayValidationRequest: DigitalWalletValidationRequest;
+    constructor({ element, controllerFrame, framepayBus, applePayValidationRequest, }: ApplePayElementParams);
+    applyStyles({ buttonColor, buttonType, buttonLanguage, }: ApplePayElementConfig['displayOptions']): void;
+    setupApplePay(): Promise<void>;
+    mount(): void;
+    onUpdateConfiguration(): Promise<void>;
+    unmount(): void;
+    destroy(): void;
+    on(eventType: string): void;
+}
+
+export declare type ApplePayElementConfig = ReturnType<typeof makeApplePayConfig>;
+
+export declare interface ApplePayElementParams {
+    element: HTMLElement;
+    controllerFrame: ControllerFrame;
+    framepayBus: EmitterInstance;
+    applePayValidationRequest: DigitalWalletValidationRequest;
+}
+
+/**
+ * Abstraction layer for the base element set to become a bban account field.
+ * Used to hide the internal implementation.
+ */
+export declare class BankElement {
+    element: BaseElement | null;
+    sourceReplaceNames: Partial<{
+        bankAccountType: string;
+        bankAccountNumber: string;
+        bankRoutingNumber: string;
+        bic: string;
+        bankName: string;
+    } & {
+        accountType: string;
+        accountNumber: string;
+        routingNumber: string;
+        bic: string;
+        bankName: string;
+    } & {
+        bic: string;
+        bankName: string;
+    }>;
+    elementParams: {
+        element: HTMLElement;
+        fieldType: string;
+        controllerFrame: ControllerFrame;
+    };
+    constructor({ element, fieldType, controllerFrame, sourceReplaceNames, }: BankElementParams);
+    /**
+     * Create new BaseElement instance with constructor params
+     *
+     * @returns {BaseElement}
+     */
+    createElement(): void;
+    mount(): void;
+    unmount(): void;
+    destroy(): void;
+    on<T extends keyof BaseElementEventMap>(eventType: T, delegate: (...args: BaseElementEventMap[T]) => void): void;
+}
+
+export declare interface BankElementParams {
+    element: HTMLElement;
+    fieldType: string;
+    controllerFrame: ControllerFrame;
+    sourceReplaceNames: BankElementSourceReplaceNames;
+}
+
+export declare type BankElementSourceReplaceNames = Partial<typeof PUBLIC_FIELD_SOURCE_NAMES_REPLACE_MAP.bankAccount & typeof PUBLIC_FIELD_SOURCE_NAMES_REPLACE_MAP.bban & typeof PUBLIC_FIELD_SOURCE_NAMES_REPLACE_MAP.iban>;
+
+export declare class BaseElement {
+    #private;
+    element: HTMLElement;
+    fieldType: string;
+    controllerFrame: ControllerFrame;
+    name: string;
+    mounted: boolean;
+    destroyed: boolean;
+    initialized: boolean;
+    frameRegistration: FrameRegistration | null;
+    configurationVersion: number;
+    wrapperEl: HTMLDivElement | null;
+    /**
+     * @param params
+     * @param params.element target element to mount to
+     */
+    constructor({ element, fieldType, controllerFrame, prefix, }: {
+        element: HTMLElement;
+        fieldType: string | null;
+        controllerFrame: ControllerFrame;
+        prefix: string;
+    });
+    /**
+     * Based on the message content type apply different styles to the element wrapper
+     */
+    applyElementStyle(fieldNotification: FieldNotification): void;
+    /**
+     * Filter relayed messages from the element and emit them on the exposed bus
+     * for use by the user.
+     */
+    filterAndEmit(fieldNotification: FieldNotification): void;
+    getLabel(): false | Element;
+    detectLabel(): void;
+    mount(): void;
+    /**
+     * Unmount the card element.
+     * Note: This destroys the iframe, as you cannot unmount and remount
+     * an iframe without the contents of that iframe being destroyed and
+     * reloaded on new mount.
+     * See: https://stackoverflow.com/questions/8318264/how-to-move-an-iframe-in-the-dom-without-losing-its-state
+     */
+    unmount(): void;
+    /**
+     * Destroy the card element
+     */
+    destroy(): void;
+    /**
+     * Allow the user to plug into the change event.
+     */
+    on<T extends keyof BaseElementEventMap>(eventType: T, delegate: (...args: BaseElementEventMap[T]) => void): void;
+}
+
+export declare interface BaseElementEventMap {
+    [FieldNotification.TYPES.ready]: [];
+    [FieldNotification.TYPES.focus]: [{
+        content: string;
+    }];
+    [FieldNotification.TYPES.error]: [FramepayError];
+    [FieldNotification.TYPES.valid]: [
+        {
+        valid: boolean;
+        source: string;
+        completed?: boolean;
+    }
+    ];
+    [FieldNotification.TYPES.blur]: [{
+        content: string;
+    }];
+    [FieldNotification.TYPES.autoFillStart]: [];
+    [FieldNotification.TYPES.autoFillCancel]: [];
+    change: [
+        {
+        error: NotificationContent | FieldError;
+        source: string;
+        completed?: boolean;
+        valid?: boolean;
+    }
+    ];
+}
+
+export declare interface BaseStyleDeclaration {
+    color?: FramepayStyleValue;
+    fontFamily?: FramepayStyleValue;
+    fontSize?: FramepayStyleValue;
+    fontStyle?: FramepayStyleValue;
+    fontVariant?: FramepayStyleValue;
+    fontStretch?: FramepayStyleValue;
+    fontWeight?: FramepayStyleValue;
+    fontFeatureSettings?: FramepayStyleValue;
+    fontKerning?: FramepayStyleValue;
+    webkitFontSmoothing?: FramepayStyleValue;
+    mozOsxFontSmoothing?: FramepayStyleValue;
+    letterSpacing?: FramepayStyleValue;
+    lineHeight?: FramepayStyleValue;
+    textDecoration?: FramepayStyleValue;
+    textShadow?: FramepayStyleValue;
+    textTransform?: FramepayStyleValue;
+    textAlign?: FramepayStyleValue;
+    textRendering?: FramepayStyleValue;
+}
+
+export declare class Bban extends PaymentMethod {
+    mount(target: HTMLElement | string, fieldType: BbanFieldType): BankElement;
+}
+
+export declare interface BbanConfig {
+    bicPlaceholder?: string;
+    bankNamePlaceholder?: string;
+    accountNumber?: string | null;
+    routingNumber?: string | null;
+    type?: {
+        savings?: string | null;
+        checking?: string | null;
+        other?: string | null;
+    };
+}
+
+export declare type BbanFieldType = keyof BbanSourceMap;
+
+export declare type BbanSourceMap = Partial<typeof PUBLIC_FIELD_SOURCE_NAMES_REPLACE_MAP.bankAccount & typeof PUBLIC_FIELD_SOURCE_NAMES_REPLACE_MAP.bban>;
+
+export declare type BillingAddressChangedHandler = (billingContact: BillingContact, updateTransaction: (newTransactionData: UpdateableTransactionData) => void) => void;
+
+export declare interface BillingContact {
+    addressLines?: string[];
+    administrativeArea?: string;
+    country?: string;
+    countryCode?: string;
+    familyName?: string;
+    givenName?: string;
+    locality?: string;
+    postalCode?: string;
+    subAdministrativeArea?: string;
+    subLocality?: string;
+}
+
+export declare interface ButtonStyleConfig {
+    base?: ButtonStyleDeclaration;
+    focus?: ButtonStyleDeclaration;
+    active?: ButtonStyleDeclaration;
+}
+
+export declare interface ButtonStyleDeclaration {
+    background?: FramepayStyleValue;
+    borderColor?: FramepayStyleValue;
+    borderRadius?: FramepayStyleValue;
+    borderStyle?: FramepayStyleValue;
+    borderWidth?: FramepayStyleValue;
+    color?: FramepayStyleValue;
+    fontFamily?: FramepayStyleValue;
+    fontFeatureSettings?: FramepayStyleValue;
+    fontKerning?: FramepayStyleValue;
+    fontSize?: FramepayStyleValue;
+    fontStretch?: FramepayStyleValue;
+    fontStyle?: FramepayStyleValue;
+    fontVariant?: FramepayStyleValue;
+    fontWeight?: FramepayStyleValue;
+    letterSpacing?: FramepayStyleValue;
+    lineHeight?: FramepayStyleValue;
+    mozOsxFontSmoothing?: FramepayStyleValue;
+    textAlign?: FramepayStyleValue;
+    textDecoration?: FramepayStyleValue;
+    textRendering?: FramepayStyleValue;
+    textShadow?: FramepayStyleValue;
+    textTransform?: FramepayStyleValue;
+    webkitFontSmoothing?: FramepayStyleValue;
+    ':hover'?: ButtonStyleDeclaration;
+}
+
+export declare class Card extends PaymentMethod {
+    Brands: typeof SupportedCardBrands;
+    mount(target: HTMLElement | string, fieldType?: string): CardElement;
+}
+
+export declare const CARD_CVV_TYPES: {
+    readonly password: "password";
+    readonly text: "text";
+};
+
+export declare const CARD_EXPIRATION_TYPES: {
+    readonly dropdown: "dropdown";
+    readonly text: "text";
+    readonly hidden: "hidden";
+};
+
+export declare interface CardConfig {
+    number?: {
+        mask: string;
+    };
+    expiry?: {
+        type: CardExpirationType;
+    };
+    expiration?: {
+        type: CardExpirationType;
+    };
+    cvv?: {
+        type: CardCvvType;
+    };
+    brands?: {
+        allowed?: string[] | null;
+    };
+}
+
+export declare type CardCvvType = ValueOf<typeof CARD_CVV_TYPES>;
+
+/**
+ * Abstraction layer for the base element set to become a payment card field.
+ * Used to hide the internal implementation.
+ */
+export declare class CardElement {
+    element: GroupFabric | BaseElement | null;
+    group: GroupFabric | null;
+    elementParams: {
+        element: HTMLElement;
+        fieldType: string;
+        controllerFrame: ControllerFrame;
+    };
+    constructor({ element, fieldType, controllerFrame }: CardElementParams);
+    /**
+     * Create new BaseElement instance with constructor params
+     */
+    createElement(): void;
+    mount(): void;
+    unmount(): void;
+    destroy(): void;
+    on<T extends keyof BaseElementEventMap>(eventType: T, delegate: (...args: BaseElementEventMap[T]) => void): void;
+}
+
+export declare interface CardElementParams {
+    element: HTMLElement;
+    fieldType: string;
+    controllerFrame: ControllerFrame;
+}
+
+export declare type CardExpirationType = ValueOf<typeof CARD_EXPIRATION_TYPES>;
+
+export declare interface ClassesConfig {
+    base?: string;
+    focus?: string;
+    group?: string;
+    dropdown?: string;
+    secondary?: string;
+    buttons?: string;
+    webkitAutofill?: string;
+    valid?: string;
+    invalid?: string;
+    input?: string;
+    googlePay?: string;
+}
+
+export declare interface Configuration {
+    publishableKey?: string;
+    applePay: ApplePayConfig;
+    bban?: unknown;
+    card: CardConfig;
+    classes: ClassesConfig;
+    googlePay: GooglePayConfig;
+    i18n: I18nConfig;
+    icon: IconConfig;
+    isParamountBankAccount?: boolean;
+    kountAccountId?: string | null;
+    locale: string;
+    methods: 'auto' | ReadyToPayObject[];
+    organizationId: string;
+    paypal: PaypalConfig;
+    placeholders: PlaceholdersConfig;
+    riskMetadata: RiskMetadata;
+    sandbox: boolean;
+    style: StyleConfig;
+    transactionData?: TransactionData;
+    websiteId: string;
+    samsungPay: SamsungPayConfig;
+}
+
+/**
+ * Controller contained within the remote controller iframe
+ */
+export declare class Controller {
+    private parentRef;
+    private firstRegisteredMethod;
+    private registeredMethods;
+    private tokenRequest;
+    private model;
+    private googlePayToken;
+    private resolveHandleBillingUpdateFromMerchantPromise;
+    private resolveHandleShippingUpdateFromMerchantPromise;
+    constructor(tokenRequest?: TokenRequest);
+    /**
+     * Check whether the controller was setup to target sandbox
+     */
+    isSandboxMode(): boolean;
+    /**
+     * Returns RebillyField list in the registered remote frames
+     */
+    getRemoteFields(method?: string): {
+        fields: Field[];
+        missing: [string, string][];
+    };
+    askParentToCreateRebillyToken(googlePayTransactionContent: GooglePayTransactionContent): void;
+    resolveHandleBillingUpdateFromMerchant(newTransactionData: ControllerTransactionData): void;
+    requestHandleBillingUpdateFromMerchant(billingContact: BillingContact): Promise<ControllerTransactionData>;
+    resolveHandleShippingUpdateFromMerchant(newTransactionData: ControllerTransactionData): void;
+    requestHandleShippingUpdateFromMerchant(shippingData: ShippingUpdateShippingData, eventType: 'address' | 'option'): Promise<ControllerTransactionData>;
+    /**
+     * Remote sibling frame registration. A remote sibling frame is a field that
+     * is on the same origin as this controller and allows us to collect its data.
+     */
+    registerSiblingFrame(registration: FrameRegistration): void;
+    /**
+     * Remote sibling frame unregistration. A remote sibling frame is a field
+     * that is on the same origin as the controller and allows us to collect its data.
+     * The field should be unregistered in unmount method see {@link base-element.unmount}
+     */
+    unregisterSiblingFrame(registration: FrameRegistration): void;
+    /**
+     * Updates the controller frames configuration and all registered remote elements
+     */
+    updateConfiguration(newConfiguration: RawConfiguration): void;
+    /**
+     * Request the field validation (revalidate all fields)
+     *
+     * @param data - some shared data from field which requested the global validation
+     */
+    requestFieldValidation(data: FieldValidationParams): void;
+    /**
+     * Request the field input focus
+     */
+    requestFieldFocus({ frame, target }: {
+        frame: string;
+        target: string;
+    }): void;
+    /**
+     * Notify all the other remote fields of a new value
+     */
+    publishFieldValueToOtherFields({ origin, source, value, }: {
+        origin: string;
+        source: string;
+        value: string;
+    }): void;
+    sendTokenRequest({ xsrfToken, data, }: {
+        xsrfToken?: string | null;
+        data: TokenRequestPayload;
+    }): Promise<TokenData>;
+    /**
+     * Request the payment token directly, without fetching data from remote frames.
+     * This is used for payment methods that do not require a separate frame (like
+     * Apple Pay, Paypal, Plaid, Klarna).
+     */
+    requestTokenWithoutRemoteFieldData(data: PrepareDigitalWalletPayloadArgs): Promise<TokenData>;
+    /**
+     * Request the field data from all remote frames and generate a token request
+     * using their responses. Returns a promise that resolves with the payment token
+     * to be consumed by the merchant context.
+     */
+    requestToken({ xsrfToken, ...otherData }?: {
+        xsrfToken?: string | null;
+        [key: string]: any;
+    }): Promise<TokenData>;
+}
+
+export declare class ControllerFrame {
+    #private;
+    name: string;
+    plugins: PluginsManager;
+    sandbox: boolean;
+    authorizationToken: string;
+    configuration: Configuration;
+    controllerFrameBus: EmitterInstance;
+    isRemoteReady: boolean;
+    queuedMessages: Array<MessageDelegate>;
+    registeredFieldTypes: Set<string>;
+    constructor({ authorizationToken, pluginManager, sandbox, }: ControllerFrameParams);
+    /**
+     * If the remote controller is ready run the delegate instantly otherwise
+     * queue it until the remote is ready.
+     */
+    queueMessage(delegate: MessageDelegate): void;
+    /**
+     * Handle the request from the controller frame, that we should request the google
+     * pay token. This request ends up being fed back to the controller frame.
+     */
+    handleRequestRebillyTokenCreationFromGooglePay(content: MerchantGooglePayTransactionContent): Promise<void>;
+    handleShippingOptionChangedEvent(shippingData: ShippingData): void;
+    handleShippingAddressChangedEvent(shippingData: AddressData): void;
+    handleBillingAddressChangedEvent(billingContact: BillingContact): void;
+    /**
+     * Register another frame that will communicate with the controller
+     */
+    registerSiblingFrame(registration: FrameRegistration): void;
+    /**
+     * Unregister a sibling frame that was previously ready to communicate
+     * with the controller.
+     */
+    unregisterSiblingFrame(registration: FrameRegistration): void;
+    setupFrame({ authorizationToken }: {
+        authorizationToken: string;
+    }): void;
+    /**
+     * Request the payment instrument token from the controller frame and
+     * provide it with the payload found in the merchant's page.
+     */
+    requestToken(...payload: Parameters<Controller['requestToken']>): ReturnType<Controller['requestToken']>;
+    requestTokenWithoutRemoteFieldData(digitalWalletPayload: Omit<PrepareDigitalWalletPayloadArgs, 'fieldType'>, fieldType: string): ReturnType<Controller['requestTokenWithoutRemoteFieldData']>;
+    /**
+     * Update configuration in the iframes
+     */
+    updateConfiguration(configuration: RawConfiguration): Promise<void>;
+}
+
+export declare interface ControllerFrameParams {
+    authorizationToken: string;
+    pluginManager: PluginsManager;
+    sandbox: boolean;
+}
+
+export declare interface ControllerTransactionData extends Omit<TransactionData, 'amount'> {
+    amount?: string;
+    shippingOptions?: ShippingOptionItem[] & {
+        options?: ShippingOptionItem[];
+        defaultSelectedOptionId?: string;
+    };
+    status?: string;
+    details: {
+        reason?: google.payments.api.ErrorReason;
+        message?: string;
+    };
+}
+
+export declare type CreatedDelegate<T> = () => T | Promise<T>;
+
+export declare class DigitalWalletValidationRequest {
+    private type;
+    /**
+     * Prepare the digital wallet validation request with the provided dependencies and config.
+     */
+    constructor({ type }: {
+        type: string;
+    });
+    /**
+     * Post to the `/digital-wallets/validation` endpoint with the provided data
+     * and return a Promise that will resolve with the response data
+     * or reject with the error object.
+     * @param args.sandbox - whether the request is to be triggered in sandbox mode
+     * @returns Rebilly BE validation response
+     */
+    post({ data, authorizationToken, organizationId, xsrfToken, sandbox, }: PostArgs): Promise<coreComponents['schemas']['ApplePayValidation']>;
+}
+
+export declare class DropDownElement {
+    element: BaseElement;
+    wrapper: {
+        node: HTMLDivElement;
+        attrs: {
+            style: string;
+        };
+    };
+    fieldType: string;
+    positionTimer: ReturnType<typeof setTimeout>;
+    constructor({ attrs, element, fieldType, controllerFrame, open, close, }: DropDownElementParams);
+    setPosition(immediately: boolean): void;
+    mount(): void;
+    unmount(): void;
+    destroy(): void;
+    on<T extends keyof BaseElementEventMap>(eventType: T, delegate: (...args: BaseElementEventMap[T]) => void): void;
+}
+
+export declare interface DropDownElementParams {
+    attrs: {
+        style: string;
+    };
+    element: HTMLElement;
+    fieldType: string;
+    controllerFrame: ControllerFrame;
+    open: string;
+    close: string;
+}
+
+export declare type EmitterInstance = typeof Emitter.prototype;
+
+/**
+ * We need to cache ready/error events callback because
+ * it can happen that the user(merchant) registers the callback after
+ * the event (ready/error) has been fired
+ */
+export declare function EventsCache(bus: EmitterInstance, eventNamesToCache: string[]): EventsCacheResult;
+
+export declare interface EventsCacheResult {
+    hasCached(eventName: string): boolean;
+    getCachedPayload(eventName: string): object | undefined;
+}
+
+export declare type ExternalPayload = {
+    leadSource?: Record<string, string>;
+};
+
+export declare interface ExtraData {
+    method?: string;
+    leadSource?: {
+        content?: string;
+        medium?: string;
+        source?: string;
+        campaign?: string;
+        affiliate?: string;
+    };
+    billingAddress?: reportsComponents['schemas']['ContactObject'] & {
+        fullName?: string;
+    };
+    shippingDetails?: {
+        address?: ApplePayJS.ApplePayPaymentContact;
+        option?: ShippingOptionItem;
+    };
+    [key: string]: string | object | undefined;
+}
+
+export declare type ExtraPayPalConfigs = Record<(typeof supportedExtraPayPalConfigs)[number], (data?: unknown) => void>;
+
+export declare class Field {
+    parentRef: FieldPostmateChildAPI | null;
+    isValid: boolean;
+    fieldErrors: FieldError[];
+    model: FieldPostmateModel | null;
+    mountingPoint: HTMLDivElement | null;
+    style: Configuration['style'] | null;
+    fieldConfig: FieldConfig | null;
+    fieldBus: EmitterInstance | null;
+    renderer: Renderer | null;
+    fieldData: FieldData;
+    get controller(): Controller;
+    constructor();
+    /**
+     * Update the configuration with the object provided and render any changes.
+     */
+    updateConfiguration(newConfig: Configuration): void;
+    /**
+     * Request the field input frame focus
+     *
+     * @param target - target frame name
+     */
+    requestFocus({ target }?: {
+        target?: string;
+    }): void;
+    requestValidation(params: FieldValidationParams): void;
+    /**
+     * Secondary field update callback
+     * Will called on each secondary field update
+     * see controller.publishUpdate
+     */
+    receiveUpdate(params: FieldReceiveUpdateParams): void;
+    registerBus(): void;
+    setupField(): void;
+    getFieldData(): Promise<{
+        isValid: boolean;
+        errors?: FieldError[];
+        data?: FieldData;
+    }>;
+    setElementValue({ fieldType, value, }: {
+        fieldType: string;
+        value: string;
+    }): void;
+    invalidateField(errorMessage: FieldError): FieldError[];
+    revalidateField(): void;
+    /**
+     * Emit a message to the base-element instance that generated this field
+     * via the `mount` method. This is INSECURE and will send and event to
+     * the merchant scope. DO NOT SHARE SENSITIVE INFORMATION HERE.
+     */
+    insecureEmitMessageToMerchantScope({ interaction, fieldType, error, completed, }: {
+        interaction?: ValueOf<typeof FieldNotification.TYPES>;
+        fieldType: string;
+        error?: false | FramepayError | string;
+        completed?: boolean;
+    }): void;
+    requestRebillyTokenCreationFromGooglePay({ transactionData, tokenData, shipping, email, }: GooglePayTransactionContent): void;
+    requestHandleShippingUpdateFromMerchant(...args: Parameters<Controller['requestHandleShippingUpdateFromMerchant']>): Promise<ControllerTransactionData>;
+    injectStyle(): void;
+}
+
+/**
+ * Internal field name ids
+ * each field with some unique functionality have unique id
+ *
+ * like "cardNumber" or "cardCvv" or "card"
+ * cardNumber - only card number
+ * cardCvv - only card cvv
+ * card - combined field with cardNumber/cvv and expiration
+ *
+ *
+ * To get the info about supported fields please take a look at
+ *
+ * This is not the api-fields, this is the UI fields,
+ * But, the fields list based on the API (card -> number + expiration + month)
+ *
+ * https://rebilly.github.io/RebillyAPI/#operation/PostToken
+ */
+export declare const FIELD_TYPES: {
+    card: string;
+    cardNumber: string;
+    khelocardNumber: string;
+    cardExpiration: string;
+    cardExpirationMonth: string;
+    cardExpirationYear: string;
+    cardCvv: string;
+    bban: string;
+    bbanAccountType: string;
+    bbanAccountNumber: string;
+    bbanRoutingNumber: string;
+    bbanBic: string;
+    bbanBankName: string;
+    iban: string;
+    ibanNumber: string;
+    ibanBic: string;
+    ibanBankName: string;
+    cardExpirationMonthList: string;
+    cardExpirationYearList: string;
+    digitalWallet: string;
+    applePay: string;
+    googlePay: string;
+    samsungPay: string;
+    paypal: string;
+    plaid: string;
+    klarna: string;
+    secondary: string;
+};
+
+export declare interface FieldConfig {
+    icon?: IconConfig;
+    isParamountBankAccount?: boolean;
+}
+
+export declare type FieldData = {
+    [key: string]: string;
+};
+
+export declare type FieldError = string | FramepayError;
+
+/**
+ * Structure defining a message sent from a field instance to its mounting element.
+ * Used as the content of a Message sent with postMessage.
+ */
+export declare class FieldNotification {
+    static TYPES: {
+        readonly focus: "focus";
+        readonly error: "error";
+        readonly valid: "valid";
+        readonly blur: "blur";
+        readonly ready: "ready";
+        readonly autoFillStart: "auto-fill-start";
+        readonly autoFillCancel: "auto-fill-cancel";
+    };
+    type: FieldNotificationType;
+    content: NotificationContent | FieldError;
+    constructor({ type, content }: NotificationArgs);
+}
+
+export declare type FieldNotificationType = ValueOf<typeof FieldNotification.TYPES>;
+
+export declare interface FieldPostmateChildAPI extends Postmate.ChildAPI {
+    model: FieldPostmateModel;
+}
+
+export declare interface FieldPostmateModel {
+    config: Configuration | null;
+    requestFocus: Field['requestFocus'];
+    controllerFrameName: string | null;
+    name: string | null;
+    instanceId: string | null;
+    fieldType: keyof typeof FIELD_TYPES | null;
+}
+
+export declare interface FieldReceiveUpdateParams {
+    origin: string;
+    source: string;
+    value: string;
+}
+
+export declare type FieldType = 'googlePay' | 'applePay' | 'plaid' | 'paypal' | 'klarna';
+
+export declare interface FieldValidationParams {
+    form?: HTMLFormElement;
+    from?: string;
+    force?: boolean;
+    source?: keyof typeof FIELD_TYPES;
+    card?: {
+        panType: null | string;
+    };
+}
+
+export declare class FramePay {
+    ControllerFrame: typeof ControllerFrame;
+    getPlugins: (configuration: Configuration) => PluginsManager;
+    controllerFrame: ControllerFrame | null;
+    authorizationToken: string;
+    version: string;
+    initialized: boolean;
+    framepayBus: EmitterInstance;
+    eventsCache: ReturnType<typeof EventsCache>;
+    plugins: PluginsManager;
+    locales: Record<string, string>;
+    errorCodes: {
+        initialized: string;
+        notInitialized: string;
+        noAPIKey: string;
+        badAPIKey: string;
+        invalidJwt: string;
+        multipleAuthorizationTokens: string;
+        mountPointNotFound: string;
+        networkError: string;
+        alreadyMounted: string;
+        invalidTokenForm: string;
+        unexpectedError: string;
+        apiError: string;
+        nonExistingAPIKey: string;
+        apiValidation: string;
+        nameRequired: string;
+        declinedBrandMessageTwoAlternatives: string;
+        declinedBrandMessageMultipleAlternatives: string;
+        organizationIdMissing: string;
+        transactionDataMissing: string;
+        merchantDataMissing: string;
+        unsupportedCardNetwork: string;
+        notReadyToPay: string;
+        googlePayDisplayOptions: string;
+        applePayDisplayOptions: string;
+        samsungPayDisplayOptions: string;
+        paypalDisplayOptions: string;
+        googlePay: string;
+        applePay: string;
+        samsungPay: string;
+        paypal: string;
+        plaid: string;
+        klarna: string;
+        invalidCountryCode: string;
+        invalidCurrencyCode: string;
+        invalidPaymentCard: string;
+        incompleteCvv: string;
+        invalidCardNumber: string;
+        invalidExpirationYearInPast: string;
+        invalidExpirationYearInFuture: string;
+        invalidExpirationMonth: string;
+        invalidExpiration: string;
+        unsupportedCardBin: string;
+        unsupportedCardBrand: string;
+        unavailableCardBrand: string;
+        invalidBbanAccount: string;
+        incompleteRoutingNumber: string;
+        invalidLengthRoutingNumber: string;
+        incompleteAccountNumber: string;
+        invalidLengthAccountNumber: string;
+        invalidMaxLengthAccountNumber: string;
+        invalidIBANNumber: string;
+        invalidIBANCountry: string;
+        unsupportedIBANCountry: string;
+        incompleteIBANNumber: string;
+        invalidCustomerFormValues: string;
+        invalidMethodsConfiguration: string;
+        unservicableShippingAddress: string;
+    };
+    setInitializedToFalseOnError: ({ code }: {
+        code: string;
+    }) => void;
+    card: Card;
+    bban: Bban;
+    iban: Iban;
+    googlePay: GooglePay;
+    applePay: ApplePay;
+    paypal: PayPal;
+    samsungPay: SamsungPay;
+    plaid: Plaid;
+    klarna: Klarna;
+    bankAccount: Bban;
+    constructor({ ControllerFrame, Card, Bban, Iban, GooglePay, ApplePay, SamsungPay, PayPal, Plaid, Klarna, getPlugins, ApplePayValidationRequest, }: FramepayParams);
+    /**
+     * Initialize FramePay and inject a controller in the page.
+     */
+    initialize({ publishableKey, jwt, ...configuration }?: FramepayInitializeParams): Promise<void>;
+    private manageRemoteFramesLoadingEvents;
+    private manageGooglePayTokenResult;
+    private manageBillingEvent;
+    private manageShippingEvents;
+    /**
+     * Trigger an update of current and future mounted element configuration.
+     */
+    update(configuration?: RawConfiguration): Promise<void>;
+    /**
+     * Create a token for the provided form and elements within (card, bban account, etc.).
+     */
+    createToken(form: Element | object | null, { xsrfToken, ...extraData }?: {
+        xsrfToken?: string;
+    } & ExtraData): Promise<TokenData>;
+    /**
+     * Subscribe to a global event
+     * @param eventType  The event type to subscribe to
+     * @param delegate   The delegate to run when the event is fired
+     */
+    on<T extends keyof FramepayEventMap>(eventType: T, delegate: (...args: FramepayEventMap[T]) => void): void;
+    /**
+     * Unsubscribe from a global event
+     * @param eventType  The event type to unsubscribe from
+     * @param delegate   The delegate to unsubscribe
+     */
+    off<T extends keyof FramepayEventMap>(eventType: T, delegate: (...args: FramepayEventMap[T]) => void): void;
+}
+
+export declare interface FramepayError {
+    code: string;
+    type?: string;
+    message?: string;
+    details?: string | string[];
+    invalidFields?: InvalidField[];
+}
+
+export declare interface FramepayEventMap {
+    ready: [];
+    error: [FramepayError];
+    'token-ready': [TokenData, ExtraData];
+    'shipping-address-changed': Parameters<ShippingAddressChangedHandler>;
+    'shipping-option-changed': Parameters<ShippingOptionsChangedHandler>;
+    'billing-address-changed': Parameters<BillingAddressChangedHandler>;
+}
+
+export declare interface FramepayInitializeParams extends RawConfiguration {
+    publishableKey?: string;
+    jwt?: string;
+}
+
+export declare interface FramepayParams {
+    ControllerFrame: typeof ControllerFrame;
+    Card: typeof Card;
+    Bban: typeof Bban;
+    Iban: typeof Iban;
+    GooglePay: typeof GooglePay;
+    ApplePay: typeof ApplePay;
+    SamsungPay: typeof SamsungPay;
+    PayPal: typeof PayPal;
+    Plaid: typeof Plaid;
+    Klarna: typeof Klarna;
+    getPlugins: typeof getPlugins;
+    ApplePayValidationRequest: DigitalWalletValidationRequest;
+}
+
+export declare type FramepayStyleValue = string | boolean | null;
+
+export declare class FrameRegistration {
+    fieldType: string;
+    name: string;
+    /**
+     * Generate a registration for a frame to be passed onto
+     * the controller.
+     * Simple structure for IDE usage.
+     */
+    constructor({ fieldType, name }: {
+        fieldType: string;
+        name: string;
+    });
+}
+
+export declare interface GeneratorParams extends MainContainer {
+    make?: MakeFn;
+    fieldBus?: EmitterInstance;
+    fieldType?: string;
+    combined?: boolean;
+    fieldConfig?: FieldConfig;
+    mountingPoint?: HTMLElement;
+    baseField?: Field;
+}
+
+export declare const getPlugins: (configuration: Configuration) => PluginsManager;
+
+export declare class GooglePay extends PaymentMethod {
+    GooglePayMarkIcon: string;
+    mount(target: HTMLElement | string): GooglePayElement;
+}
+
+export declare interface GooglePayConfig {
+    buttonColor?: google.payments.api.ButtonColor | null;
+    buttonHeight?: string | null;
+    buttonLocale?: string | null;
+    buttonSizeMode?: google.payments.api.ButtonSizeMode | null;
+    buttonType?: google.payments.api.ButtonType | null;
+    shippingAddressRequired?: boolean;
+}
+
+/**
+ * Abstraction layer for the base element set to become a Google Pay field.
+ * Used to hide the internal implementation.
+ */
+export declare class GooglePayElement {
+    element: BaseElement | null;
+    elementParams: {
+        element: HTMLElement;
+        fieldType: string;
+        controllerFrame: ControllerFrame;
+    };
+    constructor({ element, controllerFrame, }: {
+        element: HTMLElement;
+        controllerFrame: ControllerFrame;
+    });
+    /**
+     * Returns new BaseElement instance with constructor params
+     */
+    createElement(): void;
+    mount(): void;
+    unmount(): void;
+    destroy(): void;
+    on(eventType: never, _delegate: never): void;
+}
+
+export declare type GooglePayToken = object;
+
+export declare interface GooglePayTransactionContent {
+    tokenData: GooglePayToken;
+    transactionData: {
+        amount: number;
+        currency: string;
+        countryCode: string;
+        label: string;
+    };
+    shipping: {
+        address: google.payments.api.Address;
+        option: google.payments.api.SelectionOptionData;
+    };
+    email: string;
+}
+
+export declare class GroupFabric {
+    elements: (BaseElement | DropDownElement)[];
+    events: {};
+    constructor({ elements }: GroupFabricParams);
+    /**
+     * Create and append the group dom element (wrapper) of the group elements
+     * @see methods/card-element.js
+     *
+     * @param parent - the element which was passed to the element.mount(argument)
+     */
+    static appendGroupContainer(parent: HTMLElement): HTMLDivElement;
+    mount(): void;
+    unmount(): void;
+    destroy(): void;
+    on<T extends keyof BaseElementEventMap>(eventType: T, delegate: (...args: BaseElementEventMap[T]) => void): void;
+}
+
+export declare interface GroupFabricParams {
+    elements: (BaseElement | DropDownElement)[];
+}
+
+export declare interface I18nConfig {
+    [locale: string]: {
+        validations: Partial<I18nValidations>;
+    };
+}
+
+export declare interface I18nValidations {
+    'declined-brand-multiple-alternatives': string | null;
+    'declined-brand-two-alternatives': string | null;
+    'fullname-required': string | null;
+    'incomplete-account-number': string | null;
+    'incomplete-cvv': string | null;
+    'incomplete-iban-number': string | null;
+    'incomplete-routing-number': string | null;
+    'invalid-bban-account': string | null;
+    'invalid-expiration': string | null;
+    'invalid-expiration-month': string | null;
+    'invalid-expiration-year-in-future': string | null;
+    'invalid-expiration-year-in-past': string | null;
+    'invalid-iban-country': string | null;
+    'invalid-iban-number': string | null;
+    'invalid-length-account-number': string | null;
+    'invalid-length-routing-number': string | null;
+    'invalid-max-length-account-number': string | null;
+    'invalid-number': string | null;
+    'invalid-payment-card': string | null;
+    'unavailable-card-brand': string | null;
+    'unexpected-error': string | null;
+    'unservicable-shipping-address': string | null;
+    'unsupported-card-bin': string | null;
+    'unsupported-iban-country': string | null;
+}
+
+export declare class Iban extends PaymentMethod {
+    mount(target: HTMLElement | string, fieldType?: IbanFieldType): IbanElement;
+}
+
+/**
+ * Abstraction layer for the base element set to become a bban account field.
+ * Used to hide the internal implementation.
+ */
+export declare class IbanElement {
+    element: BaseElement | null;
+    elementParams: {
+        element: HTMLElement;
+        fieldType: string;
+        controllerFrame: ControllerFrame;
+    };
+    sourceReplaceNames: Partial<{
+        bic: string;
+        bankName: string;
+    }>;
+    constructor({ element, fieldType, sourceReplaceNames, controllerFrame, }: IbanElementParams);
+    /**
+     * Returns new BaseElement instance with constructor params
+     */
+    createElement(): void;
+    mount(): void;
+    unmount(): void;
+    destroy(): void;
+    on<T extends keyof BaseElementEventMap>(eventType: T, delegate: (...args: BaseElementEventMap[T]) => void): void;
+}
+
+export declare interface IbanElementParams {
+    element: HTMLElement;
+    fieldType: string;
+    sourceReplaceNames: IbanElementSourceReplaceNames;
+    controllerFrame: ControllerFrame;
+}
+
+export declare type IbanElementSourceReplaceNames = Partial<typeof PUBLIC_FIELD_SOURCE_NAMES_REPLACE_MAP.iban>;
+
+export declare type IbanFieldType = keyof IbanSourceMap | 'iban';
+
+export declare type IbanSourceMap = Partial<typeof PUBLIC_FIELD_SOURCE_NAMES_REPLACE_MAP.iban>;
+
+export declare interface IconConfig {
+    display?: boolean;
+    color?: string;
+}
+
+export declare interface InvalidField {
+    field?: string;
+    message: string;
+}
+
+export declare class Klarna extends PaymentMethod {
+    mount(target?: HTMLElement | string): KlarnaElement;
+}
+
+export declare interface KlarnaConfig {
+    clientToken: string;
+    sessionId: string;
+}
+
+export declare class KlarnaElement {
+    #private;
+    klarnaInstance: null;
+    htmlTargetElement: HTMLElement;
+    element: {
+        name: string;
+    };
+    controllerFrame: ControllerFrame;
+    klarnaContainer: HTMLDivElement;
+    constructor({ element, controllerFrame, framepayBus, }: {
+        element: HTMLElement;
+        controllerFrame: ControllerFrame;
+        framepayBus: EmitterInstance;
+    });
+    static getConfig(): KlarnaConfig;
+    setupKlarna(): Promise<void>;
+    mount(): void;
+    onUpdateConfiguration(): Promise<void>;
+    unmount(): void;
+    on(eventType: never): void;
+}
+
+export declare type LeadSource = coreComponents['schemas']['LeadSource'];
+
+export declare type LeadSourceResult = {
+    leadSource: LeadSource;
+};
+
+export declare interface LineItem {
+    label: string;
+    amount: string;
+    status?: string;
+}
+
+export declare function loadFramepay({ scriptLink, styleLink, }?: Partial<Options>): Promise<FramePay>;
+
+export declare interface MainContainer {
+    mainContainer?: HTMLElement;
+}
+
+/**
+ * Generate an element using a tag name and optionally a set of classes,
+ * style and other attributes.
+ */
+export declare function make<T extends keyof HTMLElementTagNameMap | keyof SVGElementTagNameMap>(tag: T, { cssClasses, style, attrs, textContent, }?: MakeParams): HTMLElement;
+
+/**
+ * Returns the Apple Pay field specific configuration based
+ * on the full FramePay configuration
+ */
+export declare const makeApplePayConfig: (configuration: RawConfiguration) => {
+    organizationId: string;
+    displayName: string;
+    domainName: string;
+    allowedCardBrands: string[];
+    countryCode: string;
+    currency: string;
+    amount: number;
+    label: string;
+    displayOptions: ApplePayConfig;
+    shippingConfiguration: {
+        requiredShippingContactFields: ApplePayJS.ApplePayContactField[];
+        shippingMethods?: ShippingOptionItem[];
+    };
+    lineItems: LineItem[];
+};
+
+export declare type MakeAttrs = Record<string, string | boolean>;
+
+export declare type MakeFn = typeof make;
+
+export declare interface MakeParams {
+    make?: MakeFn;
+    type?: keyof HTMLElementTagNameMap;
+    cssClasses?: string | string[];
+    style?: Record<string, string>;
+    attrs?: MakeAttrs;
+    textContent?: string;
+    placeholder?: {
+        type?: string;
+        attrs?: MakeAttrs;
+        cssClasses?: string[];
+        textContent?: string;
+    };
+    options?: string[];
+    value?: string;
+    mountingPoint?: HTMLElement;
+}
+
+/**
+ * Returns the Samsung Pay configuration based
+ * on the full FramePay configuration
+ */
+export declare const makeSamsungPayConfig: (configuration: RawConfiguration) => {
+    organizationId: string;
+    displayName: string;
+    domainName: string;
+    allowedCardBrands: string[];
+    countryCode: string;
+    currency: string;
+    amount: number;
+    label: string;
+    displayOptions: SamsungPayConfig;
+    lineItems: LineItem[];
+    sandbox: boolean;
+};
+
+export declare interface MerchantGooglePayTransactionContent extends Omit<GooglePayTransactionContent, 'tokenData'> {
+}
+
+export declare type MessageDelegate = () => void;
+
+export declare interface NotificationArgs {
+    type: FieldNotificationType;
+    content?: NotificationContent | FieldError;
+}
+
+export declare interface NotificationContent {
+    completed: boolean;
+    details: string[];
+    message: string;
+}
+
+declare interface Options {
+    scriptLink?: string;
+    styleLink?: string;
+}
+
+export declare class PaymentMethod {
+    protected parent: FramePay;
+    protected options: PaymentMethodOptions;
+    constructor(framePay: FramePay, options?: PaymentMethodOptions);
+    /**
+     * Find target HTML element
+     */
+    static findTarget(target?: HTMLElement | string): HTMLElement;
+}
+
+export declare interface PaymentMethodOptions {
+    isBankAccountOldField?: boolean;
+}
+
+export declare class PayPal extends PaymentMethod {
+    mount(target?: HTMLElement | string, { extraData }?: {
+        extraData?: ExtraPayPalConfigs;
+    }): PayPalElement;
+}
+
+export declare interface PaypalConfig {
+    buttonColor?: string;
+    buttonHeight?: string | number;
+    buttonShape?: string;
+}
+
+export declare class PayPalElement {
+    #private;
+    htmlTargetElement: HTMLElement;
+    element: {
+        name: string;
+    };
+    controllerFrame: ControllerFrame;
+    extraData: ExtraPayPalConfigs;
+    paypalButton: HTMLDivElement;
+    constructor({ element, controllerFrame, extraData, framepayBus, }: PayPalElementConstructorArgs);
+    setupPayPal(): Promise<void>;
+    mount(): void;
+    onUpdateConfiguration(): Promise<void>;
+    unmount(): void;
+    destroy(): void;
+    on(eventType: never, _delegate: never): void;
+}
+
+export declare interface PayPalElementConstructorArgs {
+    element: HTMLElement;
+    controllerFrame: ControllerFrame;
+    extraData: ExtraPayPalConfigs;
+    framepayBus: EmitterInstance;
+}
+
+export declare interface PlaceholdersConfig {
+    bban?: BbanConfig;
+    bankAccount?: BbanConfig;
+    card?: {
+        number?: string | null;
+        expiration?: string | null;
+        cvv?: string | null;
+        expirationSeparator?: string | null;
+        expirationMonth?: string | null;
+        expirationYear?: string | null;
+        expiry?: string | null;
+        expiryMoth?: string | null;
+        expiryYear?: string | null;
+        expirySeparator?: string | null;
+    };
+    iban?: {
+        bicTitle?: string | null;
+        bicPlaceholder?: string | null;
+        bankNameTitle?: string | null;
+        bankNamePlaceholder?: string | null;
+        accountNumber?: string | null;
+    };
+}
+
+export declare interface PlaceholderStyleConfig extends BaseStyleDeclaration {
+    wordSpacing?: FramepayStyleValue;
+    opacity?: FramepayStyleValue;
+    content?: FramepayStyleValue;
+}
+
+export declare class Plaid extends PaymentMethod {
+    mount(target: HTMLElement | string, { form, extraData }: PlaidOptions): PlaidElement;
+}
+
+export declare class PlaidElement {
+    #private;
+    htmlTargetElement: HTMLElement;
+    element: {
+        name: string;
+    };
+    controllerFrame: ControllerFrame;
+    form: HTMLElement;
+    plaidButton: HTMLButtonElement;
+    extraData: ExtraData;
+    constructor({ element, controllerFrame, form, extraData, framepayBus, }: PlaidElementContructorArgs);
+    loadPlaid(configuration: PlaidElementConfig): Promise<void>;
+    setupPlaid(): void;
+    mount(): void;
+    onUpdateConfiguration(): Promise<void>;
+    unmount(): void;
+    destroy(): void;
+    on(eventType: never, _delegate: never): void;
+}
+
+export declare interface PlaidElementConfig {
+    sandbox: boolean;
+    plaidLinkToken: string;
+}
+
+export declare interface PlaidElementContructorArgs {
+    element: HTMLElement;
+    controllerFrame: ControllerFrame;
+    form: HTMLElement;
+    extraData: ExtraData;
+    framepayBus: EmitterInstance;
+}
+
+export declare interface PlaidOptions {
+    form: HTMLElement;
+    extraData?: ExtraData;
+}
+
+/**
+ * Helper class for uniform plugin behavior and structure.
+ */
+declare class Plugin_2<T> {
+    created: CreatedDelegate<T> | null;
+    runtime: RuntimeDelegate<T> | null;
+    payload: T | null;
+    /**
+     * Create a plugin with the provided callbacks for initialization and runtime.
+     * @param args.created runs when the plugin is initialized
+     * @param args.runtime runs when `createToken` is triggered
+     */
+    constructor({ created, runtime, }: {
+        created?: CreatedDelegate<T>;
+        runtime?: RuntimeDelegate<T>;
+    });
+    /**
+     * Runs when the plugin instance is created at the time
+     * the page loads. If a `created` delegate was defined in the plugin
+     * it will run at this time and whatever value returned will be cached
+     * into the instance payload.
+     */
+    initialize(): void;
+    /**
+     * Runs the async plugin `runtime` delegate if present and returns the
+     * cached payload.
+     * @param externalPayload Defines the payload provided as `extraData` by the user
+     */
+    run(externalPayload: ExternalPayload): T | Promise<T>;
+}
+export { Plugin_2 as Plugin }
+
+export declare class PluginsManager {
+    private plugins;
+    constructor(plugins?: Plugin_2<unknown>[]);
+    /**
+     * Resolve all async payloads from plugins.
+     * @param externalPayload Defines the payload provided as `extraData` by the user
+     */
+    getPayloads(externalPayload: ExternalPayload): Promise<AllPossibleRuntimePluginReturnTypes>;
+}
+
+export declare interface PostArgs {
+    data: object;
+    organizationId: string;
+    authorizationToken: string;
+    xsrfToken?: string;
+    sandbox: boolean;
+}
+
+export declare type PostTokenData = object;
+
+export declare interface PrepareDigitalWalletPayloadArgs {
+    transactionData?: {
+        amount: number;
+        currency: string;
+        label: string;
+    };
+    riskMetadata?: RiskMetadata;
+    leadSource?: LeadSource;
+    googlePayToken?: GooglePayToken;
+    payPalMerchantSessionId?: string;
+    tokenData?: PostTokenData;
+    formData?: {
+        billingAddress?: object;
+    };
+    fieldType: FieldType;
+}
+
+/**
+ * Out clients want to use the friendly names like "bic", "bankName", "cvv"
+ * but in the internal functionality we should use id "bbanBic", "ibanBic", "cardCvv"
+ *
+ * to able clients to use friendly ids we should make some override
+ *
+ * client names -> internal names (mount method)
+ * internal names -> client names (method listeners, like change event source property)
+ *
+ *
+ * {
+ *     [root-field-category-like iban or bban] : {
+ *      [public-field-id] : 'internal-field-id'
+ *    }
+ * }
+ *
+ * by default method use passed value as fallback
+ * (if the method haven't any overrides in the replace map)
+ * that needs for some system fields like dropdowns and etc.
+ *
+ * so don't worry about system fields (we don't need to implement replace_map for system fields)
+ *
+ * that also means if you will use something like Framepay.bban.mount('...', 'bbanAccountType')
+ * this method will work (the fallback value of field type will be as passed value)
+ *
+ * but clients should use only correct and friendly names like Framepay.bban.mount('...', 'bic')
+ *
+ * see details in methods/*.js (how works mount method)
+ */
+export declare const PUBLIC_FIELD_SOURCE_NAMES_REPLACE_MAP: {
+    bankAccount: {
+        bankAccountType: string;
+        bankAccountNumber: string;
+        bankRoutingNumber: string;
+        bic: string;
+        bankName: string;
+    };
+    bban: {
+        accountType: string;
+        accountNumber: string;
+        routingNumber: string;
+        bic: string;
+        bankName: string;
+    };
+    iban: {
+        bic: string;
+        bankName: string;
+    };
+    digitalWallet: {
+        applePay: string;
+        googlePay: string;
+        samsungPay: string;
+    };
+};
+
+export declare interface RawConfiguration {
+    publishableKey?: string;
+    applePay?: ApplePayConfig;
+    bankAccount?: unknown;
+    bban?: unknown;
+    card?: CardConfig;
+    classes?: ClassesConfig;
+    googlePay?: GooglePayConfig;
+    i18n?: I18nConfig;
+    icon?: IconConfig;
+    isParamountBankAccount?: boolean;
+    kountAccountId?: string;
+    locale?: string;
+    methods?: 'auto' | ReadyToPayObject[];
+    organizationId?: string;
+    paypal?: PaypalConfig;
+    placeholders?: PlaceholdersConfig;
+    sandbox?: boolean;
+    style?: StyleConfig;
+    transactionData?: TransactionData;
+    websiteId?: string;
+    samsungPay?: SamsungPayConfig;
+}
+
+export declare interface ReadyToPayObject {
+    method: string;
+    filters?: string[];
+    brands?: string[];
+    feature?: Record<string, string>;
+}
+
+export declare interface RenderableField {
+    mainContainer: HTMLElement;
+    fieldType: string;
+    update: (generatorParams: GeneratorParams, { fieldType, mainContainer, }: {
+        fieldType: string;
+        mainContainer: HTMLElement;
+    }) => void;
+}
+
+export declare class Renderer {
+    #private;
+    fieldType: string;
+    fieldBus: EmitterInstance;
+    mountingPoint: HTMLDivElement | null;
+    fieldConfig: FieldConfig | null;
+    baseField: Field;
+    mainForm: HTMLElement | null;
+    field: RenderableField | RenderableField[] | null;
+    constructor({ fieldType, fieldBus, mountingPoint, fieldConfig, baseField, }: RendererConstructorParams);
+    static make: typeof make;
+    /**
+     * Update the rendering of the elements based on the configuration object.
+     */
+    update({ fieldConfig }: {
+        fieldConfig: FieldConfig;
+    }): void;
+    /**
+     * Render the field element and fork the rendering logic based
+     * on the provided type at instantiation.
+     */
+    render(): void;
+}
+
+export declare interface RendererConstructorParams {
+    fieldType: string;
+    fieldBus: EmitterInstance;
+    mountingPoint: HTMLDivElement | null;
+    fieldConfig: FieldConfig | null;
+    baseField: Field;
+}
+
+export declare interface RiskMetadata {
+    browserData?: {
+        colorDepth: string;
+        isJavaEnabled: string;
+        language: string;
+        screenHeight: string;
+        screenWidth: string;
+        timeZoneOffset: string;
+    };
+    extraData?: {
+        kountFraudSessionId?: string;
+        payPalMerchantSessionId?: string;
+    };
+    fingerprint?: string;
+}
+
+export declare type RuntimeDelegate<T> = (externalPayload: ExternalPayload) => T | Promise<T>;
+
+export declare class SamsungPay extends PaymentMethod {
+    mount(target: HTMLElement | string): SamsungPayElement;
+}
+
+export declare interface SamsungPayConfig {
+    buttonColor?: 'white' | 'black';
+}
+
+export declare class SamsungPayElement {
+    element: BaseElement | null;
+    elementParams: {
+        element: HTMLElement;
+        fieldType: string;
+        controllerFrame: ControllerFrame;
+    };
+    htmlTargetElement: HTMLElement;
+    framepayBus: EmitterInstance;
+    controllerFrame: ControllerFrame;
+    samsungPayButton: HTMLButtonElement;
+    constructor({ element, controllerFrame, framepayBus, }: {
+        element: HTMLElement;
+        controllerFrame: ControllerFrame;
+        framepayBus: EmitterInstance;
+    });
+    applyStyles(buttonColor?: SamsungPayElementConfig['displayOptions']['buttonColor']): void;
+    setupSamsungPay(): Promise<void>;
+    mount(): void;
+    unmount(): void;
+    destroy(): void;
+    onUpdateConfiguration(): Promise<void>;
+    on(): void;
+}
+
+export declare type SamsungPayElementConfig = ReturnType<typeof makeSamsungPayConfig>;
+
+export declare interface SelectionStyleConfig {
+    background?: FramepayStyleValue;
+    backgroundColor?: FramepayStyleValue;
+    color?: FramepayStyleValue;
+    textShadow?: FramepayStyleValue;
+}
+
+export declare type ShippingAddressChangedHandler = (shippingData: AddressData, updateTransaction: (newTransactionData: ShippingAddressUpdatableTransactionData) => void) => void;
+
+export declare interface ShippingAddressUpdatableTransactionData extends Partial<UpdateableTransactionData> {
+    status: 'success' | 'fail';
+    shippingOptions?: ShippingOptionItem[];
+}
+
+export declare interface ShippingData {
+    id: string;
+    label: string;
+    description: string;
+    amount: number;
+}
+
+export declare interface ShippingOptionItem {
+    id: string;
+    label: string;
+    description: string;
+    amount: number;
+}
+
+export declare interface ShippingOptions {
+    defaultSelectedOptionId?: string | null;
+    options?: ShippingOptionItem[];
+    shippingOptionParameters?: {
+        defaultSelectedOptionId: string | null;
+        shippingOptions: ShippingOptionItem[];
+    };
+}
+
+export declare type ShippingOptionsChangedHandler = (shippingData: ShippingData, updateTransaction: (newTransactionData: UpdateableTransactionData) => void) => void;
+
+export declare interface ShippingUpdateShippingData {
+    amount?: string;
+    countryCode?: string;
+    postalCode?: string;
+    locality?: string;
+    administrativeArea?: string;
+}
+
+export declare interface StyleConfig {
+    base?: StyleDeclaration;
+    focus?: StyleDeclaration;
+    valid?: StyleDeclaration;
+    invalid?: StyleDeclaration;
+    buttons?: ButtonStyleConfig;
+}
+
+export declare interface StyleDeclaration extends BaseStyleDeclaration {
+    ':focus'?: BaseStyleDeclaration;
+    ':hover'?: BaseStyleDeclaration;
+    ':disabled'?: BaseStyleDeclaration;
+    ':webkitAutofill'?: WebskitAutofillStyleConfig;
+    '::placeholder'?: PlaceholderStyleConfig;
+    '::selection'?: SelectionStyleConfig;
+}
+
+/**
+ * Public FramePay constant Framepay.card.Brands
+ */
+export declare const SupportedCardBrands: Record<string, string>;
+
+export declare const supportedExtraPayPalConfigs: string[];
+
+export declare interface TokenData {
+    id: string;
+    paymentInstrument: object;
+}
+
+export declare class TokenRequest {
+    /**
+     * Post to the `/tokens` endpoint with the provided data and return a Promise
+     * that will resolve with the response data or reject with the error object.
+     *
+     * @param sandbox define whether the request is to be triggered in sandbox mode
+     */
+    post({ data, authorizationToken, organizationId, xsrfToken, sandbox, }: {
+        data: TokenRequestPayload & {
+            [key: string]: any;
+        };
+        authorizationToken: string;
+        organizationId: string;
+        xsrfToken: string;
+        sandbox: boolean;
+    }): Promise<TokenData>;
+}
+
+export declare interface TokenRequestPayload {
+    method?: string;
+    paymentInstrument?: {
+        type?: string;
+        amount?: string;
+        currency?: string;
+        descriptor?: string;
+        payload?: PostTokenData;
+        expMonth?: string;
+        expYear?: string;
+    };
+    billingAddress?: reportsComponents['schemas']['ContactObject'];
+    riskMetadata?: RiskMetadata;
+    leadSource?: LeadSource;
+    cardExpiry?: {
+        expMonth?: string;
+        expYear?: string;
+    };
+}
+
+export declare interface TransactionData {
+    amount: number | null;
+    currency: string | null;
+    label?: string | null;
+    requestShipping?: boolean;
+    shippingOptions?: ShippingOptions;
+    lineItems?: LineItem[];
+}
+
+export declare interface UpdateableTransactionData {
+    amount: number;
+    lineItems?: LineItem[];
+}
+
+export declare type ValueOf<T> = T[keyof T];
+
+export declare interface WebskitAutofillStyleConfig {
+    fontSize?: FramepayStyleValue;
+    webkitTextFillColor?: FramepayStyleValue;
+}
+
+export { }
+
+
+declare global {
+    interface Window {
+        Rebilly: FramePay;
+        Framepay: FramePay;
+    }
+}