@payrails/web-sdk 5.10.0 → 5.12.0-RC.0

package/payrails.d.ts

@@ -1,1130 +1,1266 @@
-/// <reference types="applepayjs" />
-/// <reference types="googlepay" />
 import { LogLevel as LogLevel$1 } from '@payrails/logger';
+import { FraudProvider } from '@payrails/fraud-sdk';
 
-declare enum PAYMENT_METHOD_CODES {
-    'CARD' = "card",
-    'GOOGLE_PAY' = "googlePay",
-    'PAYPAL' = "payPal",
-    'APPLE_PAY' = "applePay",
-    'GENERIC_REDIRECT' = "genericRedirect"
-}
-declare enum PAYMENT_INSTRUMENT_STATUS {
-    'ENABLED' = "enabled",
-    'CREATED' = "created",
-    'DELETED' = "deleted",
-    'DISABLED' = "disabled",
-    'INVALID' = "invalid",
-    'TRANSIENT' = "transient"
-}
-declare class WorkflowExecution {
-    private executionResponse;
-    constructor(executionResponse: WorkflowExecutionResponse);
-    get lookup(): {
-        httpCode: number;
-        body: {
-            data: {
-                paymentCompositionOptions: StorablePaymentCompositionOption<CardMetadata | PayPalMetadata, ApplePayConfig | PayPalConfig | GooglePayConfig | undefined>[];
-            };
-            links: {
-                authorize: {
-                    href: string;
-                    method: "POST";
-                };
-                execution: string;
-            };
-            name: "lookup";
-        };
-    } | undefined;
-    get holderReference(): string;
-    get savedCreditCards(): StoredPaymentInstrument<CardMetadata>[];
-    get savedPaypalAccounts(): StoredPaymentInstrument<PayPalMetadata>[];
-    get savedGooglePayAccounts(): StoredPaymentInstrument<CardMetadata>[];
-    get savedApplePayAccounts(): StoredPaymentInstrument<CardMetadata>[];
-    get paypalConfig(): PayPalConfig;
-    get googlePayConfig(): GooglePayConfig[];
-    isPaymentMethodAvailable(paymentMethod: PAYMENT_METHOD_CODES): boolean;
-    get applePayConfig(): {
-        merchantIdentifier: string;
-        supportedNetworks: string[];
-        countryCode: string;
-        merchantCapabilities: ApplePayJS.ApplePayMerchantCapability[];
-    };
-    get url(): string;
-    get response(): WorkflowExecutionResponse;
-    get meta(): {
-        customer?: {
-            country?: {
-                code?: string | undefined;
-            } | undefined;
-        } | undefined;
-        order?: {
-            billingAddress?: {
-                country?: {
-                    code?: string | undefined;
-                } | undefined;
-            } | undefined;
-        } | undefined;
-    };
-    get availablePaymentMethods(): StorablePaymentCompositionOption<CardMetadata | PayPalMetadata, ApplePayConfig | PayPalConfig | GooglePayConfig | undefined>[];
-    get authorizeLink(): string | undefined;
-    get createSessionLink(): string | undefined;
-    get storedPaymentInstruments(): StoredPaymentInstrument<PayPalMetadata & CardMetadata>[];
-    private getStoredInstrumentForPaymentMethod;
-}
-interface WorkflowExecutionResponse {
-    id: string;
-    merchantReference: string;
-    holderReference: string;
-    actionRequired?: string;
-    meta: {
-        customer?: {
-            country?: {
-                code?: string;
-            };
-        };
-        order?: {
-            billingAddress?: {
-                country?: {
-                    code?: string;
-                };
-            };
-        };
-    };
-    status: Array<{
-        code: string;
-        time: string;
-    }>;
-    initialResults: Array<{
-        httpCode: number;
-        body: {
-            data: {
-                paymentCompositionOptions: Array<StorablePaymentCompositionOption>;
-            };
-            links: {
-                authorize: {
-                    href: string;
-                    method: 'POST';
-                };
-                execution: string;
-            };
-            name: 'lookup';
-        };
-    }>;
-    links: {
-        startPaymentSession?: {
-            href: string;
-            method: 'POST';
-        };
-        confirm?: {
-            href: string;
-            action?: {
-                parameters?: {
-                    orderId?: string;
-                    tokenId?: string;
-                };
-            };
-        };
-        redirect?: string;
-        '3ds'?: string;
-        self: string;
-    };
-    workflow: {
-        code: string;
-        version: number;
-    };
-}
-interface BasePaymentMethodConfig {
-    paymentMethodCode: PAYMENT_METHOD_CODES;
-}
-interface StorablePaymentCompositionOption<I = CardMetadata | PayPalMetadata, C = undefined | ApplePayConfig | PayPalConfig | GooglePayConfig> extends BasePaymentMethodConfig {
-    id: string;
-    description?: string;
-    status: PAYMENT_INSTRUMENT_STATUS;
-    integrationType: INTEGRATION_TYPE;
-    config: C;
-    clientConfig?: {
-        flow?: PAYMENT_CLIENT_FLOW;
-    };
-    paymentInstruments?: Array<StoredPaymentInstrument<I>>;
-}
-interface GooglePayConfig {
-    parameters: {
-        allowedAuthMethods: google.payments.api.CardAuthMethod[];
-        allowedCardNetworks: google.payments.api.CardNetwork[];
-    };
-    tokenizationSpecification: google.payments.api.PaymentMethodTokenizationSpecification;
-    type: google.payments.api.PaymentMethodType;
-}
-interface PayPalConfig {
-    clientId: string;
-    merchantId: string;
-    captureMode: 'Delayed' | 'Instant' | 'Manual';
-}
-interface ApplePayConfig {
-    parameters: {
-        merchantIdentifier: string;
-        supportedNetworks: string[];
-        countryCode: string;
-        merchantCapabilities: ApplePayJS.ApplePayMerchantCapability[];
-    };
-    type: string;
-}
-interface StoredPaymentInstrument<T = CardMetadata | PayPalMetadata> {
-    id: string;
-    status: PAYMENT_INSTRUMENT_STATUS;
-    paymentMethod: PAYMENT_METHOD_CODES;
-    displayName?: string;
-    data?: T;
-}
-interface PayPalMetadata {
-    email?: string;
-}
-interface CardMetadata {
-    bin?: string;
-    suffix?: string;
-    network?: string;
-}
-declare enum PAYMENT_CLIENT_FLOW {
-    'REDIRECT' = "redirect",
-    'DIRECT' = "direct"
-}
-declare enum INTEGRATION_TYPE {
-    API = "api",
-    HPP = "hpp"
+declare enum PAYMENT_METHOD_CODES {
+    'CARD' = "card",
+    'GOOGLE_PAY' = "googlePay",
+    'PAYPAL' = "payPal",
+    'APPLE_PAY' = "applePay",
+    'GENERIC_REDIRECT' = "genericRedirect"
+}
+declare enum PAYMENT_INSTRUMENT_STATUS {
+    'ENABLED' = "enabled",
+    'CREATED' = "created",
+    'DELETED' = "deleted",
+    'DISABLED' = "disabled",
+    'INVALID' = "invalid",
+    'TRANSIENT' = "transient"
+}
+declare class WorkflowExecution {
+    private executionResponse;
+    constructor(executionResponse: WorkflowExecutionResponse);
+    get lookup(): {
+        httpCode: number;
+        body: {
+            data: {
+                paymentCompositionOptions: Array<StorablePaymentCompositionOption>;
+            };
+            links: {
+                authorize: {
+                    href: string;
+                    method: "POST";
+                };
+                execution: string;
+            };
+            name: "lookup";
+        };
+    } | undefined;
+    get holderReference(): string;
+    get savedCreditCards(): StoredPaymentInstrument<CardMetadata>[];
+    get savedPaypalAccounts(): StoredPaymentInstrument<PayPalMetadata>[];
+    get savedGooglePayAccounts(): StoredPaymentInstrument<CardMetadata>[];
+    get savedApplePayAccounts(): StoredPaymentInstrument<CardMetadata>[];
+    get paypalConfig(): PayPalConfig;
+    get googlePayConfig(): GooglePayConfig[];
+    isPaymentMethodAvailable(paymentMethod: PAYMENT_METHOD_CODES): boolean;
+    get applePayConfig(): {
+        merchantIdentifier: string;
+        supportedNetworks: string[];
+        countryCode: string;
+        merchantCapabilities: ApplePayJS.ApplePayMerchantCapability[];
+    };
+    get url(): string;
+    get response(): WorkflowExecutionResponse;
+    get meta(): {
+        customer?: {
+            country?: {
+                code?: string;
+            };
+        };
+        order?: {
+            billingAddress?: {
+                country?: {
+                    code?: string;
+                };
+            };
+        };
+    };
+    get availablePaymentMethods(): StorablePaymentCompositionOption<CardMetadata | PayPalMetadata, ApplePayConfig | PayPalConfig | GooglePayConfig | undefined>[];
+    get authorizeLink(): string | undefined;
+    get createSessionLink(): string | undefined;
+    get storedPaymentInstruments(): StoredPaymentInstrument<PayPalMetadata & CardMetadata>[];
+    isPaymentInstallmentsEnabled(paymentMethod: PAYMENT_METHOD_CODES): boolean | undefined;
+    getPaymentInstallmentOptions(paymentMethod: PAYMENT_METHOD_CODES): PaymentInstallmentsConfig;
+    private getStoredInstrumentForPaymentMethod;
+    getPaymentMethodForStoredInstrument<T extends CardMetadata | PayPalMetadata>(instrument: StoredPaymentInstrument<T>): {
+        id: string;
+        description?: string;
+        status: PAYMENT_INSTRUMENT_STATUS;
+        integrationType: INTEGRATION_TYPE;
+        config: ApplePayConfig | PayPalConfig | GooglePayConfig | undefined;
+        clientConfig?: {
+            flow?: PAYMENT_CLIENT_FLOW;
+            supportsInstallments?: boolean;
+            installments?: PaymentInstallmentsConfig;
+        };
+        paymentMethodCode: PAYMENT_METHOD_CODES;
+    } | undefined;
+    getPaymentMethodConfig(paymentMethod: StorablePaymentCompositionOption): {
+        id: string;
+        description?: string;
+        status: PAYMENT_INSTRUMENT_STATUS;
+        integrationType: INTEGRATION_TYPE;
+        config: ApplePayConfig | PayPalConfig | GooglePayConfig | undefined;
+        clientConfig?: {
+            flow?: PAYMENT_CLIENT_FLOW;
+            supportsInstallments?: boolean;
+            installments?: PaymentInstallmentsConfig;
+        };
+        paymentMethodCode: PAYMENT_METHOD_CODES;
+    };
+}
+interface WorkflowExecutionResponse {
+    id: string;
+    merchantReference: string;
+    holderReference: string;
+    actionRequired?: string;
+    meta: {
+        customer?: {
+            country?: {
+                code?: string;
+            };
+        };
+        order?: {
+            billingAddress?: {
+                country?: {
+                    code?: string;
+                };
+            };
+        };
+    };
+    status: Array<{
+        code: string;
+        time: string;
+    }>;
+    initialResults: Array<{
+        httpCode: number;
+        body: {
+            data: {
+                paymentCompositionOptions: Array<StorablePaymentCompositionOption>;
+            };
+            links: {
+                authorize: {
+                    href: string;
+                    method: 'POST';
+                };
+                execution: string;
+            };
+            name: 'lookup';
+        };
+    }>;
+    links: {
+        startPaymentSession?: {
+            href: string;
+            method: 'POST';
+        };
+        confirm?: {
+            href: string;
+            action?: {
+                parameters?: {
+                    orderId?: string;
+                    tokenId?: string;
+                };
+            };
+        };
+        redirect?: string;
+        '3ds'?: string;
+        self: string;
+    };
+    workflow: {
+        code: string;
+        version: number;
+    };
+}
+interface BasePaymentMethodConfig {
+    paymentMethodCode: PAYMENT_METHOD_CODES;
+}
+interface BaseInstallmentOption {
+    count: number;
+    amount: number;
+}
+interface PaymentInstallmentsConfig {
+    [key: string]: BaseInstallmentOption[];
+}
+interface StorablePaymentCompositionOption<I = CardMetadata | PayPalMetadata, C = undefined | ApplePayConfig | PayPalConfig | GooglePayConfig> extends BasePaymentMethodConfig {
+    id: string;
+    description?: string;
+    status: PAYMENT_INSTRUMENT_STATUS;
+    integrationType: INTEGRATION_TYPE;
+    config: C;
+    clientConfig?: {
+        flow?: PAYMENT_CLIENT_FLOW;
+        supportsInstallments?: boolean;
+        installments?: PaymentInstallmentsConfig;
+    };
+    paymentInstruments?: Array<StoredPaymentInstrument<I>>;
+}
+interface GooglePayConfig {
+    parameters: {
+        allowedAuthMethods: google.payments.api.CardAuthMethod[];
+        allowedCardNetworks: google.payments.api.CardNetwork[];
+    };
+    tokenizationSpecification: google.payments.api.PaymentMethodTokenizationSpecification;
+    type: google.payments.api.PaymentMethodType;
+}
+interface PayPalConfig {
+    clientId: string;
+    merchantId: string;
+    captureMode: 'Delayed' | 'Instant' | 'Manual';
+}
+interface ApplePayConfig {
+    parameters: {
+        merchantIdentifier: string;
+        supportedNetworks: string[];
+        countryCode: string;
+        merchantCapabilities: ApplePayJS.ApplePayMerchantCapability[];
+    };
+    type: string;
+}
+interface StoredPaymentInstrument<T = CardMetadata | PayPalMetadata> {
+    id: string;
+    status: PAYMENT_INSTRUMENT_STATUS;
+    paymentMethod: PAYMENT_METHOD_CODES;
+    displayName?: string;
+    data?: T;
+}
+interface PayPalMetadata {
+    email?: string;
+}
+interface CardMetadata {
+    bin?: string;
+    suffix?: string;
+    network?: string;
+    binLookup?: {
+        issuerCountry: {
+            code: string;
+            name: string;
+            iso3: string;
+        };
+    };
+}
+declare enum PAYMENT_CLIENT_FLOW {
+    'REDIRECT' = "redirect",
+    'DIRECT' = "direct"
+}
+declare enum INTEGRATION_TYPE {
+    API = "api",
+    HPP = "hpp"
+}
+
+interface SaveInstrumentResponse {
+    id: string;
+    createdAt: string;
+    holderId: string;
+    paymentMethod: PAYMENT_METHOD_CODES.CARD;
+    status: PAYMENT_INSTRUMENT_STATUS;
+    data: {
+        bin: string;
+        binLookup?: {
+            bin: string;
+            network: string;
+            issuer?: string;
+            issuerCountry?: {
+                code?: string;
+                name?: string;
+                iso3?: string;
+            };
+            type?: string;
+        };
+        holderName?: string;
+        network: string;
+        suffix: string;
+        expiryMonth?: string;
+        expiryYear?: string;
+    };
+    fingerprint?: string;
+    futureUsage?: string;
 }
 
-interface SaveInstrumentResponse {
-    id: string;
-    createdAt: string;
-    holderId: string;
-    paymentMethod: PAYMENT_METHOD_CODES.CARD;
-    status: PAYMENT_INSTRUMENT_STATUS;
-    data: {
-        bin: string;
-        binLookup?: {
-            bin: string;
-            network: string;
-            issuer?: string;
-            issuerCountry?: {
-                code?: string;
-                name?: string;
-                iso3?: string;
-            };
-            type?: string;
-        };
-        holderName?: string;
-        network: string;
-        suffix: string;
-        expiryMonth?: string;
-        expiryYear?: string;
-    };
-    fingerprint?: string;
-    futureUsage?: string;
+interface BinLookupResponse {
+    bin: string;
+    network: string;
+    issuer?: string;
+    issuerCountry?: {
+        code?: string;
+        name?: string;
+        iso3?: string;
+    };
+    type?: string;
 }
 
-declare enum ElementType$1 {
-    CVV = "CVV",
-    EXPIRATION_DATE = "EXPIRATION_DATE",
-    CARD_NUMBER = "CARD_NUMBER",
-    CARDHOLDER_NAME = "CARDHOLDER_NAME",
-    INPUT_FIELD = "INPUT_FIELD",
-    PIN = "PIN",
-    EXPIRATION_MONTH = "EXPIRATION_MONTH",
-    EXPIRATION_YEAR = "EXPIRATION_YEAR"
+declare enum ElementType$1 {
+    CVV = "CVV",
+    EXPIRATION_DATE = "EXPIRATION_DATE",
+    CARD_NUMBER = "CARD_NUMBER",
+    CARDHOLDER_NAME = "CARDHOLDER_NAME",
+    INPUT_FIELD = "INPUT_FIELD",
+    PIN = "PIN",
+    EXPIRATION_MONTH = "EXPIRATION_MONTH",
+    EXPIRATION_YEAR = "EXPIRATION_YEAR"
 }
 
-declare enum RedactionType {
-    DEFAULT = "DEFAULT",
-    PLAIN_TEXT = "PLAIN_TEXT",
-    MASKED = "MASKED",
-    REDACTED = "REDACTED"
-}
-declare enum RequestMethod {
-    GET = "GET",
-    POST = "POST",
-    PUT = "PUT",
-    PATCH = "PATCH",
-    DELETE = "DELETE"
-}
-declare enum EventName {
-    CHANGE = "CHANGE",
-    READY = "READY",
-    FOCUS = "FOCUS",
-    BLUR = "BLUR",
-    SUBMIT = "SUBMIT"
-}
-declare enum LogLevel {
-    WARN = "WARN",
-    INFO = "INFO",
-    DEBUG = "DEBUG",
-    ERROR = "ERROR"
-}
-declare enum Env {
-    DEV = "DEV",
-    PROD = "PROD"
-}
-declare enum ValidationRuleType {
-    REGEX_MATCH_RULE = "REGEX_MATCH_RULE",
-    LENGTH_MATCH_RULE = "LENGTH_MATCH_RULE",
-    ELEMENT_VALUE_MATCH_RULE = "ELEMENT_VALUE_MATCH_RULE"
-}
-interface IInsertRecordInput {
-    records: IInsertRecord[];
-}
-interface IInsertRecord {
-    table: string;
-    fields: Record<string, any>;
-    skyflowID?: string;
-}
-interface Context {
-    logLevel: LogLevel;
-    env: Env;
-}
-interface IValidationRule {
-    type: ValidationRuleType;
-    params: any;
+declare enum RedactionType {
+    DEFAULT = "DEFAULT",
+    PLAIN_TEXT = "PLAIN_TEXT",
+    MASKED = "MASKED",
+    REDACTED = "REDACTED"
+}
+declare enum RequestMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}
+declare enum EventName {
+    CHANGE = "CHANGE",
+    READY = "READY",
+    FOCUS = "FOCUS",
+    BLUR = "BLUR",
+    SUBMIT = "SUBMIT"
+}
+declare enum LogLevel {
+    WARN = "WARN",
+    INFO = "INFO",
+    DEBUG = "DEBUG",
+    ERROR = "ERROR"
+}
+declare enum Env {
+    DEV = "DEV",
+    PROD = "PROD"
+}
+declare enum ValidationRuleType {
+    REGEX_MATCH_RULE = "REGEX_MATCH_RULE",
+    LENGTH_MATCH_RULE = "LENGTH_MATCH_RULE",
+    ELEMENT_VALUE_MATCH_RULE = "ELEMENT_VALUE_MATCH_RULE"
+}
+interface IInsertRecordInput {
+    records: IInsertRecord[];
+}
+interface IInsertRecord {
+    table: string;
+    fields: Record<string, any>;
+    skyflowID?: string;
+}
+interface Context {
+    logLevel: LogLevel;
+    env: Env;
+}
+interface IValidationRule {
+    type: ValidationRuleType;
+    params: any;
 }
 
-interface IUpsertOptions {
-    table: string;
-    column: string;
+interface IUpsertOptions {
+    table: string;
+    column: string;
 }
 
-declare abstract class Container {
+declare abstract class Container {
 }
 
-declare class EventEmitter {
-    events: Record<string, {
-        priority: boolean;
-        callback: Function;
-    }[]>;
-    constructor();
-    on(event: string, callback: Function, priority?: boolean): void;
-    off(event: string, callback: Function): void;
-    _emit(event: string, ...args: any[]): void;
-    hasListener(event: string): boolean;
-    resetEvents(): void;
-    static createChild(ChildObject: any): void;
+declare class EventEmitter {
+    events: Record<string, {
+        priority: boolean;
+        callback: Function;
+    }[]>;
+    constructor();
+    on(event: string, callback: Function, priority?: boolean): void;
+    off(event: string, callback: Function): void;
+    _emit(event: string, ...args: any[]): void;
+    hasListener(event: string): boolean;
+    resetEvents(): void;
+    static createChild(ChildObject: any): void;
 }
 
-declare abstract class SkyflowElement {
-    abstract mount(domElementSelector: any): any;
-    abstract unmount(): any;
-    abstract setError(clientErrorText: string): any;
-    abstract resetError(): any;
-    abstract iframeName(): any;
-    abstract getID(): any;
+declare abstract class SkyflowElement {
+    abstract mount(domElementSelector: any): any;
+    abstract unmount(): any;
+    abstract setError(clientErrorText: string): any;
+    abstract resetError(): any;
+    abstract iframeName(): any;
+    abstract getID(): any;
 }
 
-declare class CollectElement extends SkyflowElement {
-    #private;
-    elementType: string;
-    type: string;
-    containerId: string;
-    constructor(elementId: string, elementGroup: any, metaData: any, container: any, isSingleElementAPI: boolean | undefined, destroyCallback: Function, updateCallback: Function, context: Context, groupEventEmitter?: EventEmitter);
-    getID: () => string;
-    mount: (domElement: any) => void;
-    unmount: () => void;
-    update: (group: any) => void;
-    updateElement: (elementOptions: any) => void;
-    getState: () => {
-        isEmpty: boolean;
-        isComplete: boolean;
-        isValid: boolean;
-        isFocused: boolean;
-        value: string | Object | Blob | undefined;
-        required: boolean;
-    };
-    getOptions: () => any;
-    on(eventName: string, handler: any): void;
-    iframeName(): string;
-    isMounted(): boolean;
-    isValidElement(): boolean;
-    setError(clientErrorText: string): void;
-    resetError(): void;
-    setValue(elementValue: string): void;
-    clearValue(): void;
+declare class CollectElement extends SkyflowElement {
+    #private;
+    elementType: string;
+    type: string;
+    containerId: string;
+    constructor(elementId: string, elementGroup: any, metaData: any, container: any, isSingleElementAPI: boolean | undefined, destroyCallback: Function, updateCallback: Function, context: Context, groupEventEmitter?: EventEmitter);
+    getID: () => string;
+    mount: (domElement: any) => void;
+    unmount: () => void;
+    update: (group: any) => void;
+    updateElement: (elementOptions: any) => void;
+    getState: () => {
+        isEmpty: boolean;
+        isComplete: boolean;
+        isValid: boolean;
+        isFocused: boolean;
+        value: string | Object | Blob | undefined;
+        required: boolean;
+    };
+    getOptions: () => any;
+    on(eventName: string, handler: any): void;
+    iframeName(): string;
+    isMounted(): boolean;
+    isValidElement(): boolean;
+    setError(clientErrorText: string): void;
+    resetError(): void;
+    setValue(elementValue: string): void;
+    clearValue(): void;
 }
 
-interface CollectElementInput$1 {
-    table?: string;
-    column?: string;
-    inputStyles?: object;
-    label?: string;
-    labelStyles?: object;
-    errorTextStyles?: object;
-    placeholder?: string;
-    type: ElementType$1;
-    altText?: string;
-    validations?: IValidationRule[];
-    skyflowID?: string;
-}
-interface ICollectOptions$1 {
-    tokens?: boolean;
-    additionalFields?: IInsertRecordInput;
-    upsert?: Array<IUpsertOptions>;
-}
-declare class CollectContainer extends Container {
-    #private;
-    type: string;
-    private bus;
-    private iframe;
-    constructor(options: any, metaData: any, skyflowElements: any, context: any);
-    create: (input: CollectElementInput$1, options?: any) => CollectElement;
-    collect: (options?: ICollectOptions$1) => Promise<unknown>;
-    unmount: () => void;
+interface CollectElementInput$1 {
+    table?: string;
+    column?: string;
+    inputStyles?: object;
+    label?: string;
+    labelStyles?: object;
+    errorTextStyles?: object;
+    placeholder?: string;
+    type: ElementType$1;
+    altText?: string;
+    validations?: IValidationRule[];
+    skyflowID?: string;
+}
+interface ICollectOptions$1 {
+    tokens?: boolean;
+    additionalFields?: IInsertRecordInput;
+    upsert?: Array<IUpsertOptions>;
+}
+declare class CollectContainer extends Container {
+    #private;
+    type: string;
+    private bus;
+    private iframe;
+    constructor(options: any, metaData: any, skyflowElements: any, context: any);
+    create: (input: CollectElementInput$1, options?: any) => CollectElement;
+    collect: (options?: ICollectOptions$1) => Promise<unknown>;
+    unmount: () => void;
 }
 
-declare class ComposableElement {
-    #private;
-    type: string;
-    constructor(name: any, eventEmitter: any);
-    on(eventName: string, handler: any): void;
-    update: (options: any) => void;
+declare class ComposableElement {
+    #private;
+    type: string;
+    constructor(name: any, eventEmitter: any);
+    on(eventName: string, handler: any): void;
+    update: (options: any) => void;
 }
 
-interface CollectElementInput {
-    table?: string;
-    column?: string;
-    inputStyles?: object;
-    label?: string;
-    labelStyles?: object;
-    errorTextStyles?: object;
-    placeholder?: string;
-    type: ElementType$1;
-    altText?: string;
-    validations?: IValidationRule[];
-    skyflowID?: string;
-}
-interface ICollectOptions {
-    tokens?: boolean;
-    additionalFields?: IInsertRecordInput;
-    upsert?: Array<IUpsertOptions>;
-}
-declare class ComposableContainer extends Container {
-    #private;
-    type: string;
-    private bus;
-    private iframe;
-    constructor(options: any, metaData: any, skyflowElements: any, context: any);
-    create: (input: CollectElementInput, options?: any) => ComposableElement;
-    on: (eventName: string, handler: any) => void;
-    mount: (domElement: any) => void;
-    unmount: () => void;
-    collect: (options?: ICollectOptions) => Promise<unknown>;
+interface CollectElementInput {
+    table?: string;
+    column?: string;
+    inputStyles?: object;
+    label?: string;
+    labelStyles?: object;
+    errorTextStyles?: object;
+    placeholder?: string;
+    type: ElementType$1;
+    altText?: string;
+    validations?: IValidationRule[];
+    skyflowID?: string;
+}
+interface ICollectOptions {
+    tokens?: boolean;
+    additionalFields?: IInsertRecordInput;
+    upsert?: Array<IUpsertOptions>;
+}
+declare class ComposableContainer extends Container {
+    #private;
+    type: string;
+    private bus;
+    private iframe;
+    constructor(options: any, metaData: any, skyflowElements: any, context: any);
+    create: (input: CollectElementInput, options?: any) => ComposableElement;
+    on: (eventName: string, handler: any) => void;
+    mount: (domElement: any) => void;
+    unmount: () => void;
+    collect: (options?: ICollectOptions) => Promise<unknown>;
 }
 
-declare enum ContainerType {
-    COLLECT = "COLLECT",
-    COMPOSABLE = "COMPOSABLE"
-}
-interface ISkyflow {
-    vaultID?: string;
-    vaultURL?: string;
-    getBearerToken: () => Promise<string>;
-    options?: Record<string, any>;
-}
-declare class Skyflow {
-    #private;
-    private bus;
-    constructor(config: ISkyflow);
-    static init(config: ISkyflow): Skyflow;
-    container(type: ContainerType, options?: Record<string, any>): CollectContainer | ComposableContainer;
-    static get ContainerType(): typeof ContainerType;
-    static get ElementType(): typeof ElementType$1;
-    static get RedactionType(): typeof RedactionType;
-    static get RequestMethod(): typeof RequestMethod;
-    static get LogLevel(): typeof LogLevel;
-    static get EventName(): typeof EventName;
-    static get Env(): typeof Env;
-    static get ValidationRuleType(): typeof ValidationRuleType;
+declare enum ContainerType {
+    COLLECT = "COLLECT",
+    COMPOSABLE = "COMPOSABLE"
+}
+interface ISkyflow {
+    vaultID?: string;
+    vaultURL?: string;
+    getBearerToken: () => Promise<string>;
+    options?: Record<string, any>;
+}
+declare class Skyflow {
+    #private;
+    private bus;
+    constructor(config: ISkyflow);
+    static init(config: ISkyflow): Skyflow;
+    container(type: ContainerType, options?: Record<string, any>): CollectContainer | ComposableContainer;
+    static get ContainerType(): typeof ContainerType;
+    static get ElementType(): typeof ElementType$1;
+    static get RedactionType(): typeof RedactionType;
+    static get RequestMethod(): typeof RequestMethod;
+    static get LogLevel(): typeof LogLevel;
+    static get EventName(): typeof EventName;
+    static get Env(): typeof Env;
+    static get ValidationRuleType(): typeof ValidationRuleType;
 }
 
-declare enum ElementType {
-    CARD_NUMBER = "CARD_NUMBER",
-    CARDHOLDER_NAME = "CARDHOLDER_NAME",
-    CVV = "CVV",
-    EXPIRATION_MONTH = "EXPIRATION_MONTH",
-    EXPIRATION_YEAR = "EXPIRATION_YEAR"
+declare enum ElementType {
+    CARD_NUMBER = "CARD_NUMBER",
+    CARDHOLDER_NAME = "CARDHOLDER_NAME",
+    CVV = "CVV",
+    EXPIRATION_MONTH = "EXPIRATION_MONTH",
+    EXPIRATION_YEAR = "EXPIRATION_YEAR"
 }
 
-interface Mountable {
-    mount(selector: string | PayrailsElement): void;
-    unmount(): void;
-}
-interface ElementOptions {
-    id?: string;
-    className?: string | string[];
-    styles?: Partial<CSSStyleDeclaration>;
-}
-declare class PayrailsElement implements Mountable {
-    protected element: HTMLElement;
-    protected subElements: Array<Mountable>;
-    readonly id: string | undefined;
-    constructor(elementType: string, { id, className }?: ElementOptions);
-    get parentElement(): HTMLElement | null;
-    get selector(): string;
-    mount(location: string): void;
-    private clean;
-    unmount(): void;
+interface Mountable {
+    mount(selector: string | PayrailsElement): void;
+    unmount(): void;
+}
+interface ElementOptions {
+    id?: string;
+    className?: string | string[];
+    styles?: Partial<CSSStyleDeclaration>;
+}
+declare class PayrailsElement implements Mountable {
+    protected element: HTMLElement;
+    protected subElements: Array<Mountable>;
+    readonly id: string | undefined;
+    constructor(elementType: string, { id, className }?: ElementOptions);
+    get parentElement(): HTMLElement | null;
+    get selector(): string;
+    mount(location: string): void;
+    private clean;
+    unmount(): void;
 }
 
-interface StoreInstrumentElementOptions extends ElementOptions {
-    showStoreInstrumentCheckbox?: boolean;
-    alwaysStoreInstrument?: boolean;
-    translations?: {
-        labels?: {
-            storeInstrument?: string;
-            saveInstrument?: string;
-        };
-    };
-    styles?: {
-        storeInstrumentCheckbox?: Partial<CSSStyleDeclaration>;
-    };
-    events?: PayrailsSDKEvents;
-}
-declare class StoreInstrumentCheckbox extends PayrailsElement {
-    private options;
-    constructor(options: StoreInstrumentElementOptions);
-    get isChecked(): boolean;
-    private createHTML;
-    private applyStyles;
-    private addListeners;
-}
-declare abstract class PayrailsElementWithStoreInstrumentCheckbox extends PayrailsElement {
-    protected options?: StoreInstrumentElementOptions | undefined;
-    protected storeInstrumentCheckbox: StoreInstrumentCheckbox | null;
-    protected constructor(elementType: string, options?: StoreInstrumentElementOptions | undefined);
-    protected get shouldStoreInstrument(): boolean;
+interface StoreInstrumentElementOptions extends ElementOptions {
+    showStoreInstrumentCheckbox?: boolean;
+    alwaysStoreInstrument?: boolean;
+    translations?: {
+        labels?: {
+            storeInstrument?: string;
+            saveInstrument?: string;
+        };
+    };
+    styles?: {
+        storeInstrumentCheckbox?: Partial<CSSStyleDeclaration>;
+    };
+    events?: PayrailsSDKEvents;
+}
+declare class StoreInstrumentCheckbox extends PayrailsElement {
+    private options;
+    constructor(options: StoreInstrumentElementOptions);
+    get isChecked(): boolean;
+    private createHTML;
+    private applyStyles;
+    private addListeners;
+}
+declare abstract class PayrailsElementWithStoreInstrumentCheckbox extends PayrailsElement {
+    protected options?: StoreInstrumentElementOptions | undefined;
+    protected storeInstrumentCheckbox: StoreInstrumentCheckbox | null;
+    protected constructor(elementType: string, options?: StoreInstrumentElementOptions | undefined);
+    protected get shouldStoreInstrument(): boolean;
 }
 
-interface ApplePayButtonOptions extends StoreInstrumentElementOptions {
-    clientDomain?: string;
-    events?: PaymentEvents & {
-        onApplePayAvailable?: () => void;
-    };
-    styles?: {
-        type?: 'plain' | 'buy' | 'addMoney' | 'book' | 'checkout' | 'continue' | 'contribute' | 'donate' | 'inStore' | 'order' | 'reload' | 'rent' | 'setUp' | 'subscribe' | 'support' | 'tip' | 'topUp';
-        style?: 'white' | 'whiteOutline' | 'black' | 'automatic';
-    } & StoreInstrumentElementOptions['styles'];
-}
-declare global {
-    interface Window {
-        ApplePaySession?: ApplePaySession;
-    }
-}
-declare class ApplePayButton extends PayrailsElementWithStoreInstrumentCheckbox {
-    private sdkConfig;
-    private execution;
-    protected options: ApplePayButtonOptions;
-    private appleButton;
-    private paymentExecutor;
-    static isApplePayAvailable(): Promise<boolean>;
-    constructor(sdkConfig: SdkConfiguration, execution: WorkflowExecution, options: ApplePayButtonOptions);
-    mount(location: string): void;
-    unmount(): void;
-    private mountApplePayButton;
-    private createApplePaySession;
-    private onApplePayAuthorized;
+interface ApplePayButtonOptions extends StoreInstrumentElementOptions {
+    clientDomain?: string;
+    events?: PaymentEvents & {
+        onApplePayAvailable?: () => void;
+    };
+    styles?: {
+        type?: 'plain' | 'buy' | 'addMoney' | 'book' | 'checkout' | 'continue' | 'contribute' | 'donate' | 'inStore' | 'order' | 'reload' | 'rent' | 'setUp' | 'subscribe' | 'support' | 'tip' | 'topUp';
+        style?: 'white' | 'whiteOutline' | 'black' | 'automatic';
+    } & StoreInstrumentElementOptions['styles'];
+}
+declare global {
+    interface Window {
+        ApplePaySession?: ApplePaySession;
+    }
+}
+declare class ApplePayButton extends PayrailsElementWithStoreInstrumentCheckbox {
+    private sdkConfig;
+    private execution;
+    protected options: ApplePayButtonOptions;
+    private appleButton;
+    private paymentExecutor;
+    static isApplePayAvailable(): Promise<boolean>;
+    constructor(sdkConfig: SdkConfiguration, execution: WorkflowExecution, options: ApplePayButtonOptions);
+    mount(location: string): void;
+    unmount(): void;
+    private mountApplePayButton;
+    private createApplePaySession;
+    private onApplePayAuthorized;
 }
 
-declare const regexes: {
-    visa: RegExp;
-    mastercard: RegExp;
-    amex: RegExp;
-    diners: RegExp;
-    discover: RegExp;
-    jcb: RegExp;
-    hipercard: RegExp;
-    unionpay: RegExp;
-    maestro: RegExp;
-};
+declare const regexes: {
+    visa: RegExp;
+    mastercard: RegExp;
+    amex: RegExp;
+    diners: RegExp;
+    discover: RegExp;
+    jcb: RegExp;
+    hipercard: RegExp;
+    unionpay: RegExp;
+    maestro: RegExp;
+};
 type CardNetwork = keyof typeof regexes;
 
-interface OnChange {
-    isValid: boolean;
-    cardNetwork: CardNetwork | '';
-    bin?: string;
-}
-interface CardFormOptions extends StoreInstrumentElementOptions {
-    showCardHolderName?: boolean;
-    enrollInstrumentToNetworkOffers?: boolean;
-    translations?: {
-        placeholders?: {
-            [key in ElementType]?: string;
-        };
-        labels?: {
-            [key in ElementType | 'saveCreditCard']?: string;
-        } & {
-            saveInstrument?: string;
-            storeInstrument?: string;
-        };
-    };
-    events?: {
-        onFocus?: () => void;
-        onChange?: (e: OnChange) => void;
-        onSaveInstrumentCheckboxChanged?: PayrailsSDKEvents['onSaveInstrumentCheckboxChanged'];
-        onReady?: () => void;
-    };
-    styles?: {
-        wrapper?: Partial<CSSStyleDeclaration>;
-        base?: Partial<CSSStyleDeclaration>;
-        storeCardCheckbox?: Partial<CSSStyleDeclaration>;
-        errorTextStyles?: {
-            base: Partial<CSSStyleDeclaration>;
-        };
-        inputFields?: {
-            [key in ElementType | 'all']?: CardFieldStyles;
-        };
-        labels?: {
-            [key in ElementType | 'all']?: Partial<CSSStyleDeclaration>;
-        };
-    } & StoreInstrumentElementOptions['styles'];
-}
-declare class CardForm extends PayrailsElementWithStoreInstrumentCheckbox {
-    private readonly collectContainer;
-    protected readonly options?: CardFormOptions | undefined;
-    get bin(): string;
-    private readonly formFields;
-    constructor(collectContainer: PayrailsCollectContainer, options?: CardFormOptions | undefined);
-    tokenize(opts: TokenizeOptions): Promise<SaveInstrumentResponse>;
-    show(): void;
-    hide(): void;
-    private triggerOnReady;
-    private prepareLabelStyles;
-    private prepareInputStyles;
-    get isValid(): boolean;
-    get cardNetwork(): "" | "visa" | "mastercard" | "amex" | "diners" | "discover" | "jcb" | "hipercard" | "unionpay" | "maestro";
-    onChange(): void;
-    collectValues(): Promise<{
-        cardData: TokenizedCollectResult | EncryptedCollectResult;
-        storeInstrument: boolean;
-        enrollInstrumentToNetworkOffers: boolean;
-    }>;
-    private enforceEnrollInstrumentToNetworkOffersForMasterCard;
-}
-interface LabelStyles {
-    base?: Partial<CSSStyleDeclaration>;
-}
-interface CardFieldStyles extends LabelStyles {
-    complete?: Partial<CSSStyleDeclaration>;
-    empty?: Partial<CSSStyleDeclaration>;
-    focus?: Partial<CSSStyleDeclaration>;
-    invalid?: Partial<CSSStyleDeclaration>;
-    cardIcon?: Partial<CSSStyleDeclaration>;
-    copyIcon?: Partial<CSSStyleDeclaration>;
+interface PaymentInstallmentsElementOptions extends ElementOptions {
+    showPaymentInstallmentsDropdown?: boolean;
+    installmentOptions?: BaseInstallmentOption[] | null;
+    installmentCurrency?: string;
+    translations?: {
+        labels?: {
+            paymentInstallments?: string;
+        };
+    };
+    styles?: {
+        paymentInstallmentsDropdown?: Partial<CSSStyleDeclaration>;
+    };
+    events?: PayrailsSDKEvents;
+}
+declare class PaymentInstallmentsDropdown extends PayrailsElement {
+    private options;
+    constructor(options: PaymentInstallmentsElementOptions);
+    private generateOptionsHTML;
+    updateOptions(installmentOptions: BaseInstallmentOption[]): void;
+    private createHTML;
+    private applyStyles;
+    private addListeners;
+    get selectedInstallmentValue(): string | undefined;
+    setDisabled(state: boolean): void;
+}
+declare class PayrailsElementWithPaymentInstallmentsDropdown extends PayrailsElement {
+    protected options?: PaymentInstallmentsElementOptions | undefined;
+    protected paymentInstallmentsDropdown: PaymentInstallmentsDropdown | null;
+    constructor(elementType: string, options?: PaymentInstallmentsElementOptions | undefined);
+    get selectedInstallmentValue(): number;
+    updateInstallmentOptions(installmentOptions: BaseInstallmentOption[]): void;
+    setDisabled(state: boolean): void;
+}
+
+interface OnChange {
+    isValid: boolean;
+    cardNetwork: CardNetwork | '';
+    bin?: string;
+}
+interface CardFormOptions extends StoreInstrumentElementOptions {
+    showCardHolderName?: boolean;
+    enrollInstrumentToNetworkOffers?: boolean;
+    execution?: WorkflowExecution;
+    translations?: {
+        placeholders?: {
+            [key in ElementType]?: string;
+        };
+        labels?: {
+            [key in ElementType | 'saveCreditCard']?: string;
+        } & {
+            saveInstrument?: string;
+            storeInstrument?: string;
+            paymentInstallments?: string;
+        };
+    };
+    events?: {
+        onFocus?: () => void;
+        onChange?: (e: OnChange) => void;
+        onSaveInstrumentCheckboxChanged?: PayrailsSDKEvents['onSaveInstrumentCheckboxChanged'];
+        onReady?: () => void;
+    };
+    styles?: {
+        wrapper?: Partial<CSSStyleDeclaration>;
+        base?: Partial<CSSStyleDeclaration>;
+        storeCardCheckbox?: Partial<CSSStyleDeclaration>;
+        errorTextStyles?: {
+            base: Partial<CSSStyleDeclaration>;
+        };
+        inputFields?: {
+            [key in ElementType | 'all']?: CardFieldStyles;
+        };
+        labels?: {
+            [key in ElementType | 'all']?: Partial<CSSStyleDeclaration>;
+        };
+    } & StoreInstrumentElementOptions['styles'] & PaymentInstallmentsElementOptions['styles'];
+}
+declare class CardForm extends PayrailsElementWithStoreInstrumentCheckbox {
+    private readonly collectContainer;
+    protected readonly options?: CardFormOptions | undefined;
+    get bin(): string;
+    get isBinLookupEnabled(): boolean;
+    private readonly formFields;
+    private readonly paymentInstallmentsDropdown;
+    private throttledFetchBinLookup;
+    private lastBin;
+    private lastBinLookup;
+    constructor(collectContainer: PayrailsCollectContainer, options?: CardFormOptions | undefined);
+    throttledFetchBinLookupIfChanged(): Promise<BinLookupResponse | null>;
+    tokenize(opts: TokenizeOptions): Promise<SaveInstrumentResponse>;
+    show(): void;
+    hide(): void;
+    private triggerOnReady;
+    private prepareLabelStyles;
+    private prepareInputStyles;
+    get isValid(): boolean;
+    get cardNetwork(): "" | "visa" | "mastercard" | "amex" | "diners" | "discover" | "jcb" | "hipercard" | "unionpay" | "maestro";
+    onChange(): void;
+    private updateInstallments;
+    collectValues(): Promise<{
+        cardData: EncryptedCollectResult | TokenizedCollectResult;
+        storeInstrument: boolean;
+        selectedInstallment: number | undefined;
+        enrollInstrumentToNetworkOffers: boolean;
+    }>;
+    protected get selectedInstallment(): number | undefined;
+    private enforceEnrollInstrumentToNetworkOffersForMasterCard;
+    fetchBinLookup(): Promise<string | BinLookupResponse>;
+    get isPaymentInstallmentsEnabled(): boolean | undefined;
+    private getinstallmentOptions;
+}
+interface LabelStyles {
+    base?: Partial<CSSStyleDeclaration>;
+}
+interface CardFieldStyles extends LabelStyles {
+    complete?: Partial<CSSStyleDeclaration>;
+    empty?: Partial<CSSStyleDeclaration>;
+    focus?: Partial<CSSStyleDeclaration>;
+    invalid?: Partial<CSSStyleDeclaration>;
+    cardIcon?: Partial<CSSStyleDeclaration>;
+    copyIcon?: Partial<CSSStyleDeclaration>;
 }
 
-interface CardListOptions {
-    onCardChange: (selectedCard: StoredPaymentInstrument<CardMetadata>) => void;
-}
-declare class CardList extends PayrailsElement {
-    private readonly workflowExecution;
-    private listItems;
-    constructor(workflowExecution: WorkflowExecution, options?: CardListOptions);
-    reset(): void;
+interface CardListOptions {
+    onCardChange: (selectedCard: StoredPaymentInstrument<CardMetadata>) => void;
+}
+declare class CardList extends PayrailsElement {
+    private readonly workflowExecution;
+    private listItems;
+    constructor(workflowExecution: WorkflowExecution, options?: CardListOptions);
+    reset(): void;
 }
 
-interface ReturnInfo {
-    success?: string;
-    cancel?: string;
-    error?: string;
+interface ReturnInfo {
+    success?: string;
+    cancel?: string;
+    error?: string;
+}
+declare global {
+    interface Window {
+        Payrails: {
+            riskIds: {
+                [key in FraudProvider]?: string;
+            };
+        };
+    }
 }
 
-interface CardPaymentButtonOptions {
-    events?: PayrailsSDKEvents & {
-        onStateChanged?: (state: 'enabled' | 'disabled') => void;
-    };
-    translations?: {
-        label: string;
-    };
-    redirectFor3DS?: boolean;
-    styles?: {
-        base?: Partial<CSSStyleDeclaration>;
-        disabled?: Partial<CSSStyleDeclaration>;
-        loading?: Partial<CSSStyleDeclaration>;
-        hover?: Partial<CSSStyleDeclaration>;
-    };
-}
-declare class CardPaymentButton extends PayrailsElement {
-    private readonly sdkConfig;
-    private readonly execution;
-    private readonly options;
-    private readonly returnInfo?;
-    selectedInstrument: StoredPaymentInstrument | null;
-    get bin(): string | undefined;
-    private paymentExecutor;
-    private cardForm;
-    constructor(sdkConfig: SdkConfiguration, execution: WorkflowExecution, options: CardPaymentButtonOptions, returnInfo?: ReturnInfo | undefined);
-    setDisabled(isDisabled: boolean): void;
-    setSavedCreditCard(savedCard: StoredPaymentInstrument<CardMetadata>): void;
-    setSavedInstrument(savedInstrument: StoredPaymentInstrument): void;
-    private setStyles;
-    private removeStyles;
-    setLabel(label: string): void;
-    setCardForm(cardForm: CardForm): void;
-    triggerLoading(isLoading: boolean): void;
-    private onAuthorizationFailed;
-    private onPay;
-    private constructTokenizedPayment;
-    private constructEncryptedPayment;
-    private handleAuthorizationResult;
-}
-declare enum AuthorizationFailureReasons {
-    VALIDATION_FAILED = "VALIDATION_FAILED",
-    AUTHORIZATION_ERROR = "AUTHORIZATION_ERROR",
-    AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
-    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+interface CardPaymentButtonOptions {
+    events?: PayrailsSDKEvents & {
+        onStateChanged?: (state: 'enabled' | 'disabled') => void;
+    };
+    translations?: {
+        label: string;
+    };
+    redirectFor3DS?: boolean;
+    styles?: {
+        base?: Partial<CSSStyleDeclaration>;
+        disabled?: Partial<CSSStyleDeclaration>;
+        loading?: Partial<CSSStyleDeclaration>;
+        hover?: Partial<CSSStyleDeclaration>;
+    };
+}
+declare class CardPaymentButton extends PayrailsElement {
+    private readonly sdkConfig;
+    private readonly execution;
+    private readonly options;
+    private readonly returnInfo?;
+    selectedInstrument: StoredPaymentInstrument | null;
+    paymentInstallmentElement: PayrailsElementWithPaymentInstallmentsDropdown | null;
+    get bin(): string | undefined;
+    private paymentExecutor;
+    private cardForm;
+    constructor(sdkConfig: SdkConfiguration, execution: WorkflowExecution, options: CardPaymentButtonOptions, returnInfo?: ReturnInfo | undefined);
+    setDisabled(isDisabled: boolean): void;
+    setSavedCreditCard(savedCard: StoredPaymentInstrument<CardMetadata>): void;
+    setSavedInstrument(savedInstrument: StoredPaymentInstrument): void;
+    private setStyles;
+    private removeStyles;
+    setLabel(label: string): void;
+    setCardForm(cardForm: CardForm): void;
+    setPaymentInstallmentsDropdown(paymentInsallmentsDropdown: PayrailsElementWithPaymentInstallmentsDropdown): void;
+    triggerLoading(isLoading: boolean): void;
+    private onAuthorizationFailed;
+    private onPay;
+    private constructTokenizedPayment;
+    private constructEncryptedPayment;
+    private handleAuthorizationResult;
+}
+declare enum AuthorizationFailureReasons {
+    VALIDATION_FAILED = "VALIDATION_FAILED",
+    AUTHORIZATION_ERROR = "AUTHORIZATION_ERROR",
+    AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
 }
 
-interface GooglePayButtonOptions extends StoreInstrumentElementOptions {
-    environment?: PayrailsEnvironment;
-    merchantInfo?: google.payments.api.MerchantInfo;
-    redirectFor3DS?: boolean;
-    events?: PaymentEvents & UIEvents & {
-        onGooglePayAvailable?: () => void;
-    };
-    styles?: {
-        buttonColor?: google.payments.api.ButtonColor;
-        buttonType?: google.payments.api.ButtonType;
-        buttonSizeMode?: google.payments.api.ButtonSizeMode;
-        buttonLocale?: string;
-    } & StoreInstrumentElementOptions['styles'];
-}
-declare class GooglePayButton extends PayrailsElementWithStoreInstrumentCheckbox {
-    private sdkConfig;
-    private execution;
-    protected options: GooglePayButtonOptions;
-    private googleButton;
-    private readonly paymentExecutor;
-    private static googleSDKClient;
-    private static getSDKClient;
-    static isGooglePayAvailable(allowedPaymentMethods: google.payments.api.IsReadyToPayPaymentMethodSpecification[], environment?: PayrailsEnvironment, merchantInfo?: google.payments.api.MerchantInfo): Promise<boolean>;
-    constructor(sdkConfig: SdkConfiguration, execution: WorkflowExecution, options: GooglePayButtonOptions);
-    private sdkLoaded;
-    private onLoadPaymentData;
-    private authorize;
-    mount(location: string): void;
-    unmount(): void;
+interface GooglePayButtonOptions extends StoreInstrumentElementOptions {
+    environment?: PayrailsEnvironment;
+    merchantInfo?: google.payments.api.MerchantInfo;
+    redirectFor3DS?: boolean;
+    events?: PaymentEvents & UIEvents & {
+        onGooglePayAvailable?: () => void;
+    };
+    styles?: {
+        buttonColor?: google.payments.api.ButtonColor;
+        buttonType?: google.payments.api.ButtonType;
+        buttonSizeMode?: google.payments.api.ButtonSizeMode;
+        buttonLocale?: string;
+    } & StoreInstrumentElementOptions['styles'];
+}
+declare class GooglePayButton extends PayrailsElementWithStoreInstrumentCheckbox {
+    private sdkConfig;
+    private execution;
+    protected options: GooglePayButtonOptions;
+    private googleButton;
+    private readonly paymentExecutor;
+    private static googleSDKClient;
+    private static getSDKClient;
+    static isGooglePayAvailable(allowedPaymentMethods: google.payments.api.IsReadyToPayPaymentMethodSpecification[], environment?: PayrailsEnvironment, merchantInfo?: google.payments.api.MerchantInfo): Promise<boolean>;
+    constructor(sdkConfig: SdkConfiguration, execution: WorkflowExecution, options: GooglePayButtonOptions);
+    private sdkLoaded;
+    private onLoadPaymentData;
+    private authorize;
+    mount(location: string): void;
+    unmount(): void;
 }
 
-interface DropinElementEvents extends PaymentEvents {
-    onActivate?: () => void;
-    onDeactivate?: () => void;
-    onAvailable?: () => void;
-}
-interface DropinElementStyles {
-    base?: Partial<CSSStyleDeclaration>;
-    active?: Partial<CSSStyleDeclaration>;
+interface DropinElementEvents extends PaymentEvents {
+    onActivate?: () => void;
+    onDeactivate?: () => void;
+    onAvailable?: () => void;
+    onPaymentOptionVisibilityChange?: () => void;
+}
+interface DropinElementStyles {
+    base?: Partial<CSSStyleDeclaration>;
+    active?: Partial<CSSStyleDeclaration>;
 }
 
-interface ButtonOptions {
-    id: string;
-    events?: PayrailsSDKEvents & {
-        onClick?: () => Promise<void>;
-    };
-    translations: {
-        label: string;
-    };
-    styles?: {
-        base?: Partial<CSSStyleDeclaration>;
-        loading?: Partial<CSSStyleDeclaration>;
-        hover?: Partial<CSSStyleDeclaration>;
-    };
+interface ButtonOptions {
+    id: string;
+    events?: PayrailsSDKEvents & {
+        onClick?: () => Promise<void>;
+    };
+    translations: {
+        label: string;
+    };
+    styles?: {
+        base?: Partial<CSSStyleDeclaration>;
+        loading?: Partial<CSSStyleDeclaration>;
+        hover?: Partial<CSSStyleDeclaration>;
+    };
 }
 
-interface GenericRedirectButtonOptions {
-    styles?: ButtonOptions['styles'];
-    translations?: {
-        label?: string;
-    };
-    events?: PaymentEvents;
-    paymentMethod: BasePaymentMethodConfig;
-}
-declare class GenericRedirectButton extends PayrailsElement {
-    private sdkConfig;
-    private execution;
-    protected options: GenericRedirectButtonOptions;
-    private readonly returnInfo?;
-    constructor(sdkConfig: SdkConfiguration, execution: WorkflowExecution, options: GenericRedirectButtonOptions, returnInfo?: ReturnInfo | undefined);
-    private buildRedirectButton;
-    private paymentExecutor;
-    private onClick;
+interface GenericRedirectButtonOptions {
+    styles?: ButtonOptions['styles'];
+    translations?: {
+        label?: string;
+    };
+    events?: PaymentEvents;
+    paymentMethod: BasePaymentMethodConfig;
+}
+declare class GenericRedirectButton extends PayrailsElement {
+    private sdkConfig;
+    private execution;
+    protected options: GenericRedirectButtonOptions;
+    private readonly returnInfo?;
+    constructor(sdkConfig: SdkConfiguration, execution: WorkflowExecution, options: GenericRedirectButtonOptions, returnInfo?: ReturnInfo | undefined);
+    private buildRedirectButton;
+    private paymentExecutor;
+    private onClick;
 }
 
-interface GenericRedirectDropinOptions {
-    paymentMethod: StorablePaymentCompositionOption;
-    styles?: {
-        element?: DropinElementStyles;
-        button: ButtonOptions['styles'];
-    };
-    translations?: {
-        label?: string;
-        button?: GenericRedirectButtonOptions['translations'];
-    };
-    events?: DropinElementEvents & PaymentEvents;
+interface GenericRedirectDropinOptions {
+    paymentMethod: StorablePaymentCompositionOption;
+    styles?: {
+        element?: DropinElementStyles;
+        button: ButtonOptions['styles'];
+    };
+    translations?: {
+        label?: string;
+        button?: GenericRedirectButtonOptions['translations'];
+    };
+    events?: DropinElementEvents & PaymentEvents;
 }
 
-interface GooglePayDropinOptions extends GooglePayButtonOptions {
-    translations?: {
-        labels?: {
-            label?: string;
-            storeInstrument?: string;
-        };
-    };
-    styles?: GooglePayButtonOptions['styles'] & DropinElementStyles;
+interface GooglePayDropinOptions extends GooglePayButtonOptions {
+    translations?: {
+        labels?: {
+            label?: string;
+            storeInstrument?: string;
+        };
+    };
+    styles?: GooglePayButtonOptions['styles'] & DropinElementStyles;
+    events?: GooglePayButtonOptions['events'] & DropinElementEvents;
 }
 
-interface PaypalButtonOptions extends StoreInstrumentElementOptions {
-    fraudNetGuid?: string;
-    events?: PaymentEvents & UIEvents & {
-        onPaypalAvailable?: () => void;
-    };
-    styles?: {
-        color?: 'gold' | 'blue' | 'silver' | 'white' | 'black';
-        height?: number;
-        label?: 'paypal' | 'checkout' | 'buynow' | 'pay' | 'installment' | 'subscribe' | 'donate';
-        shape?: 'rect' | 'pill';
-        tagline?: boolean;
-    } & StoreInstrumentElementOptions['styles'];
-}
-declare class PaypalButton extends PayrailsElementWithStoreInstrumentCheckbox {
-    private sdkConfig;
-    private execution;
-    protected options?: PaypalButtonOptions | undefined;
-    constructor(sdkConfig: SdkConfiguration, execution: WorkflowExecution, options?: PaypalButtonOptions | undefined);
-    fraudNetGuid: string | undefined;
-    private paymentExecutor;
-    private button;
-    private confirmLink;
-    private buttonWrapperId;
-    private checkboxWrapperId;
-    private loadPaypal;
-    private get paypalScriptConfig();
-    private createPaypalButton;
-    private createPayPalButtonConfig;
-    private createBillingAgreementConfig;
-    private createOneTimeOrderConfig;
-    private createBaseConfig;
-    private createOneTimeOrder;
-    private approvePayment;
-    mount(location: string): void;
-    unmount(): void;
+interface PaypalButtonOptions extends StoreInstrumentElementOptions {
+    fraudNetGuid?: string;
+    events?: PaymentEvents & UIEvents & {
+        onPaypalAvailable?: () => void;
+    };
+    styles?: {
+        color?: 'gold' | 'blue' | 'silver' | 'white' | 'black';
+        height?: number;
+        label?: 'paypal' | 'checkout' | 'buynow' | 'pay' | 'installment' | 'subscribe' | 'donate';
+        shape?: 'rect' | 'pill';
+        tagline?: boolean;
+    } & StoreInstrumentElementOptions['styles'];
+}
+declare class PaypalButton extends PayrailsElementWithStoreInstrumentCheckbox {
+    private sdkConfig;
+    private execution;
+    protected options?: PaypalButtonOptions | undefined;
+    constructor(sdkConfig: SdkConfiguration, execution: WorkflowExecution, options?: PaypalButtonOptions | undefined);
+    fraudNetGuid: string | undefined;
+    private paymentExecutor;
+    private button;
+    private confirmLink;
+    private buttonWrapperId;
+    private checkboxWrapperId;
+    private loadPaypal;
+    private get paypalScriptConfig();
+    private createPaypalButton;
+    private createPayPalButtonConfig;
+    private createBillingAgreementConfig;
+    private createOneTimeOrderConfig;
+    private createBaseConfig;
+    private createOneTimeOrder;
+    private approvePayment;
+    mount(location: string): void;
+    unmount(): void;
 }
 
-interface PaypalDropinOptions extends PaypalButtonOptions {
-    translations?: {
-        labels?: {
-            saveInstrument?: string;
-            label?: string;
-        };
-    };
-    styles?: PaypalButtonOptions['styles'] & DropinElementStyles;
-    events?: PaypalButtonOptions['events'] & DropinElementEvents;
+interface PaypalDropinOptions extends PaypalButtonOptions {
+    translations?: {
+        labels?: {
+            saveInstrument?: string;
+            label?: string;
+        };
+    };
+    styles?: PaypalButtonOptions['styles'] & DropinElementStyles;
+    events?: PaypalButtonOptions['events'] & DropinElementEvents;
 }
 
-declare class Dropin extends PayrailsElement {
-    private collectContainer;
-    private readonly clientConfig;
-    private readonly dropinConfig;
-    private readonly execution;
-    private readonly sdkConfig;
-    private cardPaymentButton;
-    private creditCard;
-    private googlePay;
-    private applePay;
-    private cardForm;
-    private paypal;
-    constructor(collectContainer: PayrailsCollectContainer, clientConfig: PayrailsClientOptions, dropinConfig: DropinOptions, execution: WorkflowExecution, sdkConfig: SdkConfiguration);
-    private isHppIntegration;
-    private createStoredInstrumentElement;
-    private createHppIntegrationElement;
-    private get totalPaymentOptions();
-    private createCreditCardButton;
-    private createGooglePayButton;
-    private createPayPalButton;
-    private createCardForm;
-    private createApplePayButton;
-    private createCardPaymentButton;
-    private onAuthorizeSuccess;
-    private getElementEvents;
-    private onAuthorizeFailed;
-    private isStoredInstrumentEnabled;
-    private applyStyles;
-}
-interface StorablePaymentMethodConfiguration extends StoreInstrumentElementOptions {
-    showStoredInstruments?: boolean;
-}
-interface DropinOptions {
-    paymentMethodsConfiguration?: {
-        preselectFirstPaymentOption?: boolean;
-        cards?: {
-            showCardHolderName?: boolean;
-            showExistingCards?: boolean;
-        } & StorablePaymentMethodConfiguration;
-        payPal?: StorablePaymentMethodConfiguration;
-        googlePay?: StorablePaymentMethodConfiguration & {
-            merchantInfo?: GooglePayButtonOptions['merchantInfo'];
-        };
-        applePay?: {
-            clientDomain?: string;
-        } & StorablePaymentMethodConfiguration;
-    };
-    returnInfo?: ReturnInfo;
-    events?: PayrailsSDKEvents;
-    translations?: {
-        [key: string]: any;
-        googlePayButton?: GooglePayDropinOptions['translations'];
-        cardPaymentButton?: CardPaymentButtonOptions['translations'];
-        cardForm?: CardFormOptions['translations'];
-        paymentResult?: {
-            success?: string;
-            fail?: string;
-        };
-        paypalButton?: PaypalDropinOptions['translations'];
-        mercadoPago?: GenericRedirectDropinOptions['translations'];
-    };
-    styles?: {
-        [key: string]: any;
-        container?: ContainerStyles;
-        element?: DropinElementStyles;
-        googlePayButton?: GooglePayButtonOptions['styles'];
-        paypalButton?: PaypalDropinOptions['styles'];
-        applePayButton?: ApplePayButtonOptions['styles'];
-        cardForm?: CardFormOptions['styles'];
-        cardPaymentButton?: CardPaymentButtonOptions['styles'];
-        authSuccess?: Partial<CSSStyleDeclaration>;
-        authFailed?: Partial<CSSStyleDeclaration>;
-        mercadoPago?: GenericRedirectDropinOptions['styles'];
-    };
-}
-interface ContainerStyles {
-    styles?: Partial<CSSStyleDeclaration>;
+declare class Dropin extends PayrailsElement {
+    private collectContainer;
+    private readonly clientConfig;
+    private readonly dropinConfig;
+    private readonly execution;
+    private readonly sdkConfig;
+    private cardPaymentButton;
+    private creditCard;
+    private googlePay;
+    private applePay;
+    private cardForm;
+    private paypal;
+    private paymentInstallmentsDropdown;
+    constructor(collectContainer: PayrailsCollectContainer, clientConfig: PayrailsClientOptions, dropinConfig: DropinOptions, execution: WorkflowExecution, sdkConfig: SdkConfiguration);
+    private isHppIntegration;
+    private createStoredInstrumentElement;
+    private createInstallmentsDropdown;
+    private getInstallmentOptionsForInstrument;
+    private createHppIntegrationElement;
+    private get totalPaymentOptions();
+    private createCreditCardButton;
+    private createGooglePayButton;
+    private createPayPalButton;
+    private createCardForm;
+    private createApplePayButton;
+    private createCardPaymentButton;
+    private onAuthorizeSuccess;
+    private getElementEvents;
+    private onAuthorizeFailed;
+    private isStoredInstrumentEnabled;
+    private applyStyles;
+    fetchBinLookup(): Promise<string | BinLookupResponse | undefined>;
+}
+interface StorablePaymentMethodConfiguration extends StoreInstrumentElementOptions {
+    showStoredInstruments?: boolean;
+}
+interface DropinOptions {
+    paymentMethodsConfiguration?: {
+        preselectFirstPaymentOption?: boolean;
+        cards?: {
+            showCardHolderName?: boolean;
+            showExistingCards?: boolean;
+        } & StorablePaymentMethodConfiguration;
+        payPal?: StorablePaymentMethodConfiguration;
+        googlePay?: StorablePaymentMethodConfiguration & {
+            merchantInfo?: GooglePayButtonOptions['merchantInfo'];
+        };
+        applePay?: {
+            clientDomain?: string;
+        } & StorablePaymentMethodConfiguration;
+    };
+    returnInfo?: ReturnInfo;
+    events?: PayrailsSDKEvents;
+    translations?: {
+        [key: string]: any;
+        googlePayButton?: GooglePayDropinOptions['translations'];
+        cardPaymentButton?: CardPaymentButtonOptions['translations'];
+        cardForm?: CardFormOptions['translations'];
+        paymentResult?: {
+            success?: string;
+            fail?: string;
+        };
+        paypalButton?: PaypalDropinOptions['translations'];
+        mercadoPago?: GenericRedirectDropinOptions['translations'];
+    };
+    styles?: {
+        [key: string]: any;
+        container?: ContainerStyles;
+        element?: DropinElementStyles;
+        googlePayButton?: GooglePayButtonOptions['styles'];
+        paypalButton?: PaypalDropinOptions['styles'];
+        applePayButton?: ApplePayButtonOptions['styles'];
+        cardForm?: CardFormOptions['styles'];
+        cardPaymentButton?: CardPaymentButtonOptions['styles'];
+        authSuccess?: Partial<CSSStyleDeclaration>;
+        authFailed?: Partial<CSSStyleDeclaration>;
+        mercadoPago?: GenericRedirectDropinOptions['styles'];
+    };
+}
+interface ContainerStyles {
+    styles?: Partial<CSSStyleDeclaration>;
 }
 
-declare class SdkLoader {
-    static load<T = void>(sdk: ThirdPartySDK, params?: PayPalScriptConfig): Promise<T>;
-    static reset(): void;
-    static preloadCardForm(): void;
-    private static loadScript;
-    private static loadPayPalScript;
-    private static readonly scriptMap;
-    private constructor();
-    private static logLoadError;
-}
-interface PayPalScriptConfig {
-    clientId: string;
-    currency: string;
-    vault: boolean;
-    intent: 'tokenize' | 'capture' | 'authorize';
-}
-declare enum ThirdPartySDK {
-    ApplePay = "https://applepay.cdn-apple.com/jsapi/v1/apple-pay-sdk.js",
-    GooglePay = "https://pay.google.com/gp/p/js/pay.js",
-    PayPal = "paypal-sdk"
+declare class SdkLoader {
+    static load<T = void>(sdk: ThirdPartySDK, params?: PayPalScriptConfig): Promise<T>;
+    static reset(): void;
+    static preloadCardForm(): void;
+    private static loadScript;
+    private static loadPayPalScript;
+    private static readonly scriptMap;
+    private constructor();
+    private static logLoadError;
+}
+interface PayPalScriptConfig {
+    clientId: string;
+    currency: string;
+    vault: boolean;
+    intent: 'tokenize' | 'capture' | 'authorize';
+}
+declare enum ThirdPartySDK {
+    ApplePay = "https://applepay.cdn-apple.com/jsapi/v1/apple-pay-sdk.js",
+    GooglePay = "https://pay.google.com/gp/p/js/pay.js",
+    PayPal = "paypal-sdk"
 }
 
-type FraudNetPageId = 'home-page' | 'search-result-page' | 'category-page' | 'product-detail-page' | 'cart-page' | 'inline-cart-page' | 'checkout-page';
-declare class FraudNet implements Mountable {
-    private pageId;
-    private execution;
-    private environment;
-    constructor(pageId: FraudNetPageId, execution: WorkflowExecution, environment: PayrailsClientOptions['environment']);
-    readonly guid: any;
-    mount(): void;
-    unmount(): void;
-    private loadFraudnet;
-    private readonly fnclsVal;
-    private readonly configId;
-    private readonly scriptId;
-    private get payPalConfig();
-    private createFraudnetConfig;
+type FraudNetPageId = 'home-page' | 'search-result-page' | 'category-page' | 'product-detail-page' | 'cart-page' | 'inline-cart-page' | 'checkout-page';
+declare class FraudNet implements Mountable {
+    private pageId;
+    private execution;
+    private environment;
+    constructor(pageId: FraudNetPageId, execution: WorkflowExecution, environment: PayrailsClientOptions['environment']);
+    readonly guid: any;
+    mount(): void;
+    unmount(): void;
+    private loadFraudnet;
+    private readonly fnclsVal;
+    private readonly configId;
+    private readonly scriptId;
+    private get payPalConfig();
+    private createFraudnetConfig;
 }
 
-interface PayrailsClientOptions {
-    environment?: PayrailsEnvironment;
-    events?: {
-        onClientInitialized: (execution?: WorkflowExecution) => void;
-    };
-    redirectFor3DS?: boolean;
-    returnInfo?: ReturnInfo;
-    telemetry?: {
-        enabled?: boolean;
-        logLevel?: LogLevel$1;
-    };
-}
-declare class Payrails {
-    private sdkConfiguration;
-    private vaultClient;
-    private execution;
-    private options?;
-    private __container;
-    private __cardForm;
-    private __cardList;
-    private __cardPaymentButton;
-    private __fraudNet;
-    private __paypalButton;
-    private __genericRedirectButton;
-    private __dropin;
-    static preloadCardForm: typeof SdkLoader.preloadCardForm;
-    static init(initResponse: InitOptions, options?: PayrailsClientOptions): Payrails;
-    update(amount: PayrailsAmount): void;
-    collectContainer(containerOptions: CollectContainerOptions): PayrailsCollectContainer;
-    googlePayButton(options: GooglePayButtonOptions): GooglePayButton;
-    isGooglePayAvailable(merchantInfo: google.payments.api.MerchantInfo): Promise<boolean>;
-    applePayButton(options: ApplePayButtonOptions): ApplePayButton;
-    isApplePayAvailable(): Promise<boolean>;
-    cardList(options?: CardListOptions): CardList;
-    cardForm(options?: CardFormOptions): CardForm;
-    dropin(options: DropinOptions): Dropin;
-    getSavedCreditCards(): StoredPaymentInstrument<CardMetadata>[];
-    getSavedGooglePayAccounts(): StoredPaymentInstrument<CardMetadata>[];
-    getSavedApplePayAccounts(): StoredPaymentInstrument<CardMetadata>[];
-    getStoredInstruments(): StoredPaymentInstrument<PayPalMetadata & CardMetadata>[];
-    getAvailablePaymentMethods(): PAYMENT_METHOD_CODES[];
-    paymentButton(options: CardPaymentButtonOptions): CardPaymentButton;
-    paypalButton(options?: PaypalButtonOptions): PaypalButton;
-    genericRedirectButton(options: GenericRedirectButtonOptions): GenericRedirectButton;
-    getSavedPaypalAccounts(): StoredPaymentInstrument<PayPalMetadata>[];
-    fraudNet(pageId: FraudNetPageId): FraudNet;
-    private get safeExecution();
-    private logIntegrationMode;
-    private constructor();
-    private getContainerLayout;
-}
-interface InitOptions {
-    version: string;
-    data: string;
-}
-interface PaymentEvents {
-    onAuthorizeSuccess?: (e?: any) => void;
-    onAuthorizeFailed?: (e?: any) => void;
-    onPaymentButtonClicked?: (e?: {
-        bin?: string;
-    }) => Promise<boolean>;
-    onPaymentSessionExpired?: () => void;
-    onThreeDSecureChallenge?: () => void;
-}
-interface UIEvents {
-    onSaveInstrumentCheckboxChanged?: ({ checked }: {
-        checked: boolean;
-    }) => void;
-}
-type PayrailsSDKEvents = PaymentEvents & UIEvents;
-interface SdkConfiguration {
-    token: string;
-    amount: PayrailsAmount;
-    holderReference: string;
-    usePayrailsFrames: boolean;
-    vaultConfiguration: {
-        cardTableName: string;
-        token: string;
-        vaultId: string;
-        vaultUrl: string;
-        providerId: string;
-        providerConfigId: string;
-        vaultType: 'Skyflow' | 'Payrails' | 'Test';
-        encryptionPublicKey?: string;
-        links: {
-            saveInstrument: {
-                href: string;
-            };
-        };
-    };
-    execution?: WorkflowExecutionResponse;
-}
-interface PayrailsAmount {
-    value: string;
-    currency: string;
-}
-declare enum PayrailsEnvironment {
-    TEST = "TEST",
-    PRODUCTION = "PRODUCTION"
+interface PayrailsClientOptions {
+    environment?: PayrailsEnvironment;
+    events?: {
+        onClientInitialized: (execution?: WorkflowExecution) => void;
+    };
+    redirectFor3DS?: boolean;
+    returnInfo?: ReturnInfo;
+    telemetry?: {
+        enabled?: boolean;
+        logLevel?: LogLevel$1;
+    };
+}
+declare class Payrails {
+    private sdkConfiguration;
+    private vaultClient;
+    private execution;
+    private options?;
+    private __container;
+    private __cardForm;
+    private __cardList;
+    private __cardPaymentButton;
+    private __fraudNet;
+    private __paypalButton;
+    private __genericRedirectButton;
+    private __dropin;
+    static preloadCardForm: typeof SdkLoader.preloadCardForm;
+    static init(initResponse: InitOptions, options?: PayrailsClientOptions): Payrails;
+    update(amount: PayrailsAmount): void;
+    collectContainer(containerOptions: CollectContainerOptions): PayrailsCollectContainer;
+    googlePayButton(options: GooglePayButtonOptions): GooglePayButton;
+    isGooglePayAvailable(merchantInfo: google.payments.api.MerchantInfo): Promise<boolean>;
+    applePayButton(options: ApplePayButtonOptions): ApplePayButton;
+    isApplePayAvailable(): Promise<boolean>;
+    cardList(options?: CardListOptions): CardList;
+    cardForm(options?: CardFormOptions): CardForm;
+    dropin(options: DropinOptions): Dropin;
+    getSavedCreditCards(): StoredPaymentInstrument<CardMetadata>[];
+    getSavedGooglePayAccounts(): StoredPaymentInstrument<CardMetadata>[];
+    getSavedApplePayAccounts(): StoredPaymentInstrument<CardMetadata>[];
+    getStoredInstruments(): StoredPaymentInstrument<PayPalMetadata & CardMetadata>[];
+    getAvailablePaymentMethods(): PAYMENT_METHOD_CODES[];
+    paymentButton(options: CardPaymentButtonOptions): CardPaymentButton;
+    paypalButton(options?: PaypalButtonOptions): PaypalButton;
+    genericRedirectButton(options: GenericRedirectButtonOptions): GenericRedirectButton;
+    getSavedPaypalAccounts(): StoredPaymentInstrument<PayPalMetadata>[];
+    fraudNet(pageId: FraudNetPageId): FraudNet;
+    private get safeExecution();
+    private logIntegrationMode;
+    private constructor();
+    private getContainerLayout;
+    binLookup(): Promise<any>;
+}
+interface InitOptions {
+    version: string;
+    data: string;
+}
+interface PaymentEvents {
+    onAuthorizeSuccess?: (e?: any) => void;
+    onAuthorizeFailed?: (e?: any) => void;
+    onPaymentButtonClicked?: (e?: {
+        bin?: string;
+    }) => Promise<boolean>;
+    onPaymentSessionExpired?: () => void;
+    onThreeDSecureChallenge?: () => void;
+}
+interface UIEvents {
+    onSaveInstrumentCheckboxChanged?: ({ checked }: {
+        checked: boolean;
+    }) => void;
+}
+type onPaymentMethodSelectedParams = {
+    paymentMethod?: StorablePaymentCompositionOption;
+    instrument?: StoredPaymentInstrument<CardMetadata & PayPalMetadata>;
+};
+interface DropinEvents {
+    onPaymentOptionSelected?: (e: onPaymentMethodSelectedParams) => void;
+}
+type PayrailsSDKEvents = PaymentEvents & UIEvents & DropinEvents;
+interface SdkConfiguration {
+    token: string;
+    amount: PayrailsAmount;
+    holderReference: string;
+    usePayrailsFrames: boolean;
+    links?: {
+        binLookup: {
+            method: 'GET' | 'POST';
+            href: string;
+        };
+    };
+    vaultConfiguration: {
+        cardTableName: string;
+        token: string;
+        vaultId: string;
+        vaultUrl: string;
+        providerId: string;
+        providerConfigId: string;
+        vaultType: 'Skyflow' | 'Payrails' | 'Test';
+        encryptionPublicKey?: string;
+        links: {
+            saveInstrument: {
+                href: string;
+            };
+        };
+    };
+    execution?: WorkflowExecutionResponse;
+}
+interface PayrailsAmount {
+    value: string;
+    currency: string;
+}
+declare enum PayrailsEnvironment {
+    TEST = "TEST",
+    PRODUCTION = "PRODUCTION"
 }
 
-type TokenizedCollectResult = {
-    skyflow_id?: string;
-    card_number?: string;
-    cardholder_name?: string;
-    expiry_month?: string;
-    expiry_year?: string;
-    security_code: string;
-    instrumentId?: string;
-};
-interface EncryptedCollectResult {
-    vaultProviderConfigId: string;
-    encryptedData: string;
-}
-interface CollectElementOptions {
-    type: ElementType;
-    label?: string;
-    placeholder?: string;
-    altText?: string;
-    format?: string;
-    inputStyles?: object;
-    labelStyles?: object;
-    errorTextStyles?: object;
-    required?: boolean;
-    enableCardIcon?: boolean;
-}
-type PayrailsContainerType = 'COLLECT' | 'COMPOSABLE';
-interface CollectContainerOptions {
-    layout?: number[];
-    cardTableName?: string;
-    containerType?: PayrailsContainerType;
-    styles?: {
-        base?: Partial<CSSStyleDeclaration>;
-    };
-    errorTextStyles?: {
-        base?: Partial<CSSStyleDeclaration>;
-    };
-}
-type PayrailsSecureFieldEvent = 'CHANGE' | 'FOCUS' | 'BLUR' | 'READY' | 'SUBMIT';
-interface PayrailsSecureField {
-    on(eventName: PayrailsSecureFieldEvent, handler: any): void;
-    mount?: (domElement: any) => void;
-    unmount?: () => void;
-    getState?: () => {
-        isEmpty: boolean;
-        isComplete: boolean;
-        isValid: boolean;
-        isFocused: boolean;
-        value: unknown;
-        required: boolean;
-    };
-    isValidElement?: () => boolean;
-    setError?: (clientErrorText: string) => void;
-    resetError?: () => void;
-    setValue?: (elementValue: string) => void;
-    clearValue?: () => void;
-}
-declare class PayrailsCollectContainer implements Mountable {
-    private sdkConfig;
-    bin: string;
-    readonly id = "payrails-container-wrapper";
-    private static instance;
-    private readonly __container;
-    private element;
-    private readonly cardTableName;
-    private readonly containerType;
-    constructor(__client: Skyflow, options: CollectContainerOptions, sdkConfig: SdkConfiguration);
-    static init(vaultClient: Skyflow, options: CollectContainerOptions, sdkConfig: SdkConfiguration): PayrailsCollectContainer;
-    createCollectElement(options: CollectElementOptions): PayrailsSecureField;
-    mount(selector: string): void;
-    unmount(): void;
-    collect(): Promise<TokenizedCollectResult | EncryptedCollectResult>;
-    private collectSkyflowData;
-    private collectPayrailsData;
-    tokenize(opts: TokenizeOptions): Promise<SaveInstrumentResponse>;
-    private constructSaveInstrumentBody;
-    private attachCustomEventHandler;
-    private formatBin;
-    private get elementToFieldMap();
-}
-interface TokenizeOptions {
-    futureUsage?: 'CardOnFile' | 'Subscription' | 'UnscheduledCardOnFile';
-    storeInstrument?: boolean;
+type TokenizedCollectResult = {
+    skyflow_id?: string;
+    card_number?: string;
+    cardholder_name?: string;
+    expiry_month?: string;
+    expiry_year?: string;
+    security_code: string;
+    instrumentId?: string;
+};
+interface EncryptedCollectResult {
+    vaultProviderConfigId: string;
+    encryptedData: string;
+}
+interface CollectElementOptions {
+    type: ElementType;
+    label?: string;
+    placeholder?: string;
+    altText?: string;
+    format?: string;
+    inputStyles?: object;
+    labelStyles?: object;
+    errorTextStyles?: object;
+    required?: boolean;
+    enableCardIcon?: boolean;
+}
+type PayrailsContainerType = 'COLLECT' | 'COMPOSABLE';
+interface CollectContainerOptions {
+    layout?: number[];
+    cardTableName?: string;
+    containerType?: PayrailsContainerType;
+    styles?: {
+        base?: Partial<CSSStyleDeclaration>;
+    };
+    errorTextStyles?: {
+        base?: Partial<CSSStyleDeclaration>;
+    };
+}
+type PayrailsSecureFieldEvent = 'CHANGE' | 'FOCUS' | 'BLUR' | 'READY' | 'SUBMIT';
+interface PayrailsSecureField {
+    on(eventName: PayrailsSecureFieldEvent, handler: any): void;
+    mount?: (domElement: any) => void;
+    unmount?: () => void;
+    getState?: () => {
+        isEmpty: boolean;
+        isComplete: boolean;
+        isValid: boolean;
+        isFocused: boolean;
+        value: unknown;
+        required: boolean;
+    };
+    isValidElement?: () => boolean;
+    setError?: (clientErrorText: string) => void;
+    resetError?: () => void;
+    setValue?: (elementValue: string) => void;
+    clearValue?: () => void;
+}
+declare class PayrailsCollectContainer implements Mountable {
+    private sdkConfig;
+    bin: string;
+    isBinLookupEnabled: boolean;
+    readonly id = "payrails-container-wrapper";
+    private static instance;
+    private readonly __container;
+    private element;
+    private readonly cardTableName;
+    private readonly containerType;
+    constructor(__client: Skyflow, options: CollectContainerOptions, sdkConfig: SdkConfiguration);
+    static init(vaultClient: Skyflow, options: CollectContainerOptions, sdkConfig: SdkConfiguration): PayrailsCollectContainer;
+    createCollectElement(options: CollectElementOptions): PayrailsSecureField;
+    mount(selector: string): void;
+    unmount(): void;
+    collect(): Promise<TokenizedCollectResult | EncryptedCollectResult>;
+    private collectSkyflowData;
+    private collectPayrailsData;
+    tokenize(opts: TokenizeOptions): Promise<SaveInstrumentResponse>;
+    private constructSaveInstrumentBody;
+    private attachCustomEventHandler;
+    private formatBin;
+    private get elementToFieldMap();
+    fetchBinLookup: (bin: string) => Promise<string | BinLookupResponse>;
+}
+interface TokenizeOptions {
+    futureUsage?: 'CardOnFile' | 'Subscription' | 'UnscheduledCardOnFile';
+    storeInstrument?: boolean;
 }
 
 export { ApplePayButtonOptions, AuthorizationFailureReasons, CardFormOptions, CardListOptions, CardPaymentButtonOptions, DropinOptions, ElementType, GooglePayButtonOptions, INTEGRATION_TYPE, InitOptions, PAYMENT_METHOD_CODES, PaymentEvents, PaypalButtonOptions, Payrails, PayrailsAmount, PayrailsClientOptions, PayrailsContainerType, PayrailsEnvironment, PayrailsSecureField, PayrailsSecureFieldEvent, SaveInstrumentResponse, WorkflowExecutionResponse };