@adyen/adyen-web 5.5.0 → 5.7.0

package/dist/types/components/ThreeDS2/callSubmit3DS2Fingerprint.d.ts

@@ -1,5 +1,6 @@
 /**
- * ThreeDS2DeviceFingerprint, onComplete, calls a new, internal, endpoint which behaves like the /details endpoint but doesn't require the same credentials
+ * ThreeDS2DeviceFingerprint, onComplete, calls a new, internal, endpoint which
+ * behaves like the /details endpoint but doesn't require the same credentials
  */
 export default function callSubmit3DS2Fingerprint({ data }: {
     data: any;

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

@@ -41,3 +41,21 @@ export interface FingerPrintData {
     threeDSMethodNotificationURL: string;
     postMessageDomain: string;
 }
+export declare type ThreeDS2FingerprintResponse = {
+    type: 'action' | 'completed';
+    action?: CheckoutRedirectAction | CheckoutThreeDS2Action;
+    details?: Record<string, string>;
+};
+declare type CheckoutRedirectAction = {
+    type: 'redirect';
+    data: Record<string, string>;
+    method: string;
+    paymentData: string;
+};
+declare type CheckoutThreeDS2Action = {
+    type: 'threeDS2';
+    token: string;
+    subtype: string;
+    authorisationToken: string;
+};
+export {};

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

@@ -1,27 +1,26 @@
 import { h } from 'preact';
 import BaseElement from './BaseElement';
 import { Order, PaymentAction } from '../types';
-import { UIElementProps } from './types';
+import { IUIElement, UIElementProps } from './types';
 import AdyenCheckoutError from '../core/Errors/AdyenCheckoutError';
-export declare class UIElement<P extends UIElementProps = any> extends BaseElement<P> {
+import type { UIElementStatus } from './types';
+export declare class UIElement<P extends UIElementProps = any> extends BaseElement<P> implements IUIElement {
     protected componentRef: any;
     elementRef: any;
     constructor(props: P);
     setState(newState: object): void;
-    onChange(): object;
-    onSubmit(): void;
-    onValid(): {
-        data: any;
-    };
+    protected onChange(): object;
+    private onSubmit;
+    private onValid;
     onComplete(state: any): void;
     /**
      * Submit payment method data. If the form is not valid, it will trigger validation.
      */
     submit(): void;
     showValidation(): this;
-    setStatus(status: any, props?: any): this;
-    submitPayment(data: any): Promise<void>;
-    submitAdditionalDetails(data: any): Promise<void>;
+    setStatus(status: UIElementStatus, props?: any): this;
+    private submitPayment;
+    private submitAdditionalDetails;
     protected handleError: (error: AdyenCheckoutError) => void;
     protected handleAdditionalDetails: (state: any) => any;
     handleAction(action: PaymentAction, props?: {}): UIElement;
@@ -56,6 +55,6 @@ export declare class UIElement<P extends UIElementProps = any> extends BaseEleme
     /**
      * Get the payButton component for the current element
      */
-    payButton: (props: any) => h.JSX.Element;
+    protected payButton: (props: any) => h.JSX.Element;
 }
 export default UIElement;

package/dist/types/components/internal/Address/Specifications.d.ts

@@ -1,4 +1,4 @@
-import { AddressSchema } from './types';
+import { AddressSchema, StringObject } from './types';
 declare class Specifications {
     private specifications;
     constructor(specifications?: any);
@@ -21,6 +21,12 @@ declare class Specifications {
      * @returns AddressSchema
      */
     getAddressSchemaForCountry(country: string): AddressSchema;
+    /**
+     * Returns the address labels of the selected country or the default address labels.
+     * @param country - The selected country
+     * @returns StringObject
+     */
+    getAddressLabelsForCountry(country: string): StringObject;
     /**
      * Returns the optional fields of the selected country or the default optional fields.
      * @param country - The selected country

package/dist/types/components/internal/Address/types.d.ts

@@ -1,6 +1,9 @@
 import { AddressField, AddressData } from '../../../types';
 import Specifications from './Specifications';
 import { ValidatorRules } from '../../../utils/Validator/Validator';
+export declare type StringObject = {
+    [key: string]: string;
+};
 export interface AddressProps {
     allowedCountries?: string[];
     countryCode?: string;
@@ -71,13 +74,9 @@ export declare type AddressSchema = (AddressField | AddressFieldsGroup)[];
 export interface AddressSpecifications {
     [key: string]: {
         hasDataset?: boolean;
-        labels?: {
-            [key: string]: string;
-        };
+        labels?: StringObject;
         optionalFields?: AddressField[];
-        placeholders?: {
-            [key: string]: string;
-        };
+        placeholders?: StringObject;
         schema?: AddressSchema;
     };
 }

package/dist/types/components/internal/FormFields/Field/Field.d.ts

@@ -13,7 +13,7 @@ declare class Field extends Component<FieldProps, FieldState> {
         filled: any;
         focused?: undefined;
     };
-    render({ className, classNameModifiers, children, errorMessage, helper, inputWrapperModifiers, isLoading, isValid, label, dualBrandingElements, dir, name, showValidIcon }: {
+    render({ className, classNameModifiers, children, errorMessage, helper, inputWrapperModifiers, isLoading, isValid, label, dualBrandingElements, dir, name, showValidIcon, isCollatingErrors }: {
         className?: string;
         classNameModifiers?: any[];
         children: any;
@@ -27,6 +27,7 @@ declare class Field extends Component<FieldProps, FieldState> {
         dir: any;
         name: any;
         showValidIcon: any;
+        isCollatingErrors: any;
     }): h.JSX.Element;
 }
 export default Field;

package/dist/types/components/internal/FormFields/Field/types.d.ts

@@ -20,6 +20,7 @@ export interface FieldProps {
     dir?: any;
     name?: string;
     showValidIcon?: boolean;
+    isCollatingErrors?: boolean;
 }
 export interface FieldState {
     disabled?: boolean;

package/dist/types/components/internal/FormFields/Select/Select.d.ts

@@ -1,7 +1,7 @@
 import { h } from 'preact';
 import { SelectProps } from './types';
 import './Select.scss';
-declare function Select({ items, className, classNameModifiers, filterable, readonly, onChange, selected, name, isInvalid, isValid, placeholder, uniqueId }: SelectProps): h.JSX.Element;
+declare function Select({ items, className, classNameModifiers, filterable, readonly, onChange, selected, name, isInvalid, isValid, placeholder, uniqueId, isCollatingErrors }: SelectProps): h.JSX.Element;
 declare namespace Select {
     var defaultProps: {
         className: string;

package/dist/types/components/internal/FormFields/Select/types.d.ts

@@ -18,6 +18,7 @@ export interface SelectProps {
     readonly: boolean;
     selected: string;
     uniqueId?: string;
+    isCollatingErrors: boolean;
 }
 export interface SelectButtonProps {
     active: SelectItem;

package/dist/types/components/internal/SecuredFields/SFP/SFPUtils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Make an array of encrypted field names based on the value of the 'data-cse' attribute of elements in the rootNode
+ */
+export declare const getFields: (rootNode: any) => any;
+/**
+ * If, visually, we're dealing with a single date field (expiryDate) we still need separate entries
+ * for expiryMonth & expiryYear - since that is how the values will be delivered from securedFields
+ */
+export declare const validFieldsReducer: (acc: any, cur: any) => any;
+export declare const getErrorReducer: (numDateFields: any, state: any) => (acc: any, field: any) => any;
+/**
+ * Create an object suitable for sending to our handleOnError function
+ */
+export declare const getErrorObject: (fieldType: any, rootNode: any, state: any) => {
+    rootNode: any;
+    fieldType: any;
+    error: any;
+    type: string;
+};

package/dist/types/components/internal/SecuredFields/{SecuredFieldsProvider.d.ts → SFP/SecuredFieldsProvider.d.ts}

@@ -1,29 +1,8 @@
 import { Component } from 'preact';
 import { SFPProps } from './defaultProps';
-import { StylesObject, CbObjOnError } from './lib/types';
-import { AddressData } from '../../../types';
-import { BinLookupResponse } from '../../Card/types';
-import { CVCPolicyType, DatePolicyType } from './lib/core/AbstractSecuredField';
-export interface SFPState {
-    status?: string;
-    brand?: string;
-    errors?: object;
-    valid: object;
-    data: object;
-    cvcPolicy?: CVCPolicyType;
-    isSfpValid?: boolean;
-    autoCompleteName?: string;
-    billingAddress?: AddressData;
-    hasUnsupportedCard?: boolean;
-    hasKoreanFields?: boolean;
-    showSocialSecurityNumber?: boolean;
-    expiryDatePolicy?: DatePolicyType;
-    socialSecurityNumber?: string;
-}
-export interface SingleBrandResetObject {
-    brand: string;
-    cvcPolicy: CVCPolicyType;
-}
+import { StylesObject, CbObjOnError } from '../lib/types';
+import { BinLookupResponse } from '../../../Card/types';
+import { SFPState, SingleBrandResetObject } from './types';
 /**
  * SecuredFieldsProvider:
  * Initialises & handles the client-side part of SecuredFields
@@ -53,7 +32,7 @@ declare class SecuredFieldsProvider extends Component<SFPProps, SFPState> {
         keypadFix: boolean;
         rootNode: any;
         loadingContext: any;
-        groupTypes: any[];
+        brands: any[];
         allowedDOMAccess: boolean;
         showWarnings: boolean;
         autoFocus: boolean;
@@ -68,7 +47,6 @@ declare class SecuredFieldsProvider extends Component<SFPProps, SFPState> {
         onBinValue: () => void;
         onFocus: () => void;
         onAutoComplete: () => void;
-        placeholders: {};
         styles: {};
     };
     componentDidMount(): void;

package/dist/types/components/internal/SecuredFields/{SecuredFieldsProviderHandlers.d.ts → SFP/SecuredFieldsProviderHandlers.d.ts}

@@ -1,4 +1,4 @@
-import { CbObjOnError, CbObjOnFocus, CbObjOnBrand, CbObjOnAllValid, CbObjOnFieldValid, CbObjOnAutoComplete, CbObjOnConfigSuccess, CbObjOnLoad } from './lib/types';
+import { CbObjOnError, CbObjOnFocus, CbObjOnBrand, CbObjOnAllValid, CbObjOnFieldValid, CbObjOnAutoComplete, CbObjOnConfigSuccess, CbObjOnLoad } from '../lib/types';
 /**
  * Emits the onConfigSuccess (ready) event
  * Here we can assume CSF is loaded and ready to be used

package/dist/types/components/internal/SecuredFields/SFP/defaultProps.d.ts

@@ -0,0 +1,64 @@
+import { Language } from '../../../../language/Language';
+import { CardBrandsConfiguration } from '../../../Card/types';
+import { StylesObject } from '../lib/types';
+/**
+ * Should be the only props that can be sent to SFP (from CardInput, SecuredFieldsInput, AchInput, GiftcardComponent)
+ */
+export interface SFPProps {
+    allowedDOMAccess?: boolean;
+    autoFocus?: boolean;
+    brands?: string[];
+    brandsConfiguration?: CardBrandsConfiguration;
+    clientKey: string;
+    countryCode?: string;
+    hasKoreanFields?: boolean;
+    i18n: Language;
+    implementationType?: string;
+    isCollatingErrors?: boolean;
+    keypadFix?: boolean;
+    koreanAuthenticationRequired?: boolean;
+    legacyInputMode?: boolean;
+    loadingContext: string;
+    minimumExpiryDate?: string;
+    onAdditionalSFConfig?: () => {};
+    onAdditionalSFRemoved?: () => {};
+    onAllValid?: () => {};
+    onAutoComplete?: () => {};
+    onBinValue?: () => {};
+    onBrand?: () => {};
+    onChange: () => {};
+    onConfigSuccess?: () => {};
+    onError?: () => {};
+    onFieldValid?: () => {};
+    onFocus?: () => {};
+    onLoad?: () => {};
+    rootNode: HTMLElement;
+    showWarnings?: boolean;
+    styles?: StylesObject;
+    trimTrailingSeparator?: boolean;
+    type: string;
+    render: () => {};
+}
+declare const _default: {
+    type: string;
+    keypadFix: boolean;
+    rootNode: any;
+    loadingContext: any;
+    brands: any[];
+    allowedDOMAccess: boolean;
+    showWarnings: boolean;
+    autoFocus: boolean;
+    trimTrailingSeparator: boolean;
+    onChange: () => void;
+    onLoad: () => void;
+    onConfigSuccess: () => void;
+    onAllValid: () => void;
+    onFieldValid: () => void;
+    onBrand: () => void;
+    onError: () => void;
+    onBinValue: () => void;
+    onFocus: () => void;
+    onAutoComplete: () => void;
+    styles: {};
+};
+export default _default;

package/dist/types/components/internal/SecuredFields/SFP/types.d.ts

@@ -0,0 +1,32 @@
+import { CVCPolicyType, DatePolicyType } from '../lib/types';
+import { AddressData } from '../../../../types';
+export interface SFPState {
+    status?: string;
+    brand?: string;
+    errors?: object;
+    valid: SFPValid;
+    data: object;
+    cvcPolicy?: CVCPolicyType;
+    isSfpValid?: boolean;
+    autoCompleteName?: string;
+    billingAddress?: AddressData;
+    hasUnsupportedCard?: boolean;
+    hasKoreanFields?: boolean;
+    showSocialSecurityNumber?: boolean;
+    expiryDatePolicy?: DatePolicyType;
+    socialSecurityNumber?: string;
+}
+export interface SingleBrandResetObject {
+    brand: string;
+    cvcPolicy: CVCPolicyType;
+}
+export interface SFPValid {
+    encryptedCardNumber?: boolean;
+    encryptedExpiryMonth?: boolean;
+    encryptedExpiryYear?: boolean;
+    encryptedSecurityCode?: boolean;
+    encryptedPassword?: boolean;
+    encryptedPin?: boolean;
+    encryptedBankAccountNumber?: boolean;
+    encryptedBankLocationId?: boolean;
+}

package/dist/types/components/internal/SecuredFields/lib/{core → CSF}/AbstractCSF.d.ts

@@ -1,14 +1,15 @@
-import { CSFSetupObject, CSFConfigObject, CSFCallbacksConfig, CSFStateObject, SFFeedbackObj, SendBrandObject, SendExpiryDateObject } from '../types';
-import { createSecuredFields } from './createSecuredFields';
-import { handleProcessBrand } from './utils/processBrand';
-import { handleBrandFromBinLookup } from './utils/handleBrandFromBinLookup';
+import { CSFSetupObject, CSFConfigObject, CSFCallbacksConfig, CSFStateObject } from './types';
+import { SFFeedbackObj, SendBrandObject, SendExpiryDateObject } from '../types';
+import { createSecuredFields } from './extensions/createSecuredFields';
+import processBrand from './partials/processBrand';
+import handleBrandFromBinLookup from './extensions/handleBrandFromBinLookup';
 declare abstract class AbstractCSF {
     protected callbacks: CSFCallbacksConfig;
     protected config: CSFConfigObject;
     protected props: CSFSetupObject;
     protected state: CSFStateObject;
-    protected assessFormValidity: () => void;
-    protected brandsFromBinLookup: typeof handleBrandFromBinLookup;
+    protected validateForm: () => void;
+    protected handleBrandFromBinLookup: typeof handleBrandFromBinLookup;
     protected callbacksHandler: (callbacksObj: object) => void;
     protected configHandler: () => void;
     protected createCardSecuredFields: (securedFields: HTMLElement[]) => number;
@@ -27,7 +28,7 @@ declare abstract class AbstractCSF {
     protected isConfigured: () => void;
     protected postMessageToAllIframes: (pDataObj: object) => void;
     protected processAutoComplete: (pFeedbackObj: SFFeedbackObj) => void;
-    protected processBrand: typeof handleProcessBrand;
+    protected processBrand: typeof processBrand;
     protected sendBrandToCardSF: (brandObj: SendBrandObject) => void;
     protected sendExpiryDatePolicyToSF: (dateObj: SendExpiryDateObject) => void;
     protected setFocusOnFrame: (pFieldType: string, doLog?: boolean) => void;

package/dist/types/components/internal/SecuredFields/lib/{core → CSF}/CSF.d.ts

@@ -1,12 +1,8 @@
 import AbstractCSF from './AbstractCSF';
-import { CSFReturnObject, CSFSetupObject } from '../types';
+import { CSFReturnObject, CSFSetupObject } from './types';
 declare class CSF extends AbstractCSF {
     constructor(setupObj: CSFSetupObject);
     private init;
     createReturnObject(): CSFReturnObject;
-    /**
-     * Retrieves the iframe, stored by field type, & returns it's contentWindow
-     */
-    private getIframeContentWin;
 }
 export default CSF;

package/dist/types/components/internal/SecuredFields/lib/{core/utils → CSF/extensions}/handleBrandFromBinLookup.d.ts

@@ -2,4 +2,4 @@ import { SendBrandObject, SendExpiryDateObject } from '../../types';
 import { BinLookupResponse } from '../../../../../Card/types';
 export declare function sendBrandToCardSF(brandObj: SendBrandObject): void;
 export declare function sendExpiryDatePolicyToSF(expiryDateObj: SendExpiryDateObject): void;
-export declare function handleBrandFromBinLookup(binLookupResponse: BinLookupResponse): void;
+export default function handleBrandFromBinLookup(binLookupResponse: BinLookupResponse): void;

package/dist/types/components/internal/SecuredFields/lib/{core → CSF/extensions}/handleEncryption.d.ts

@@ -1,2 +1,2 @@
-import { SFFeedbackObj } from '../types';
+import { SFFeedbackObj } from '../../types';
 export declare function handleEncryption(pFeedbackObj: SFFeedbackObj): void;

package/dist/types/components/internal/SecuredFields/lib/{core → CSF/extensions}/handleValidation.d.ts

@@ -1,2 +1,2 @@
-import { SFFeedbackObj } from '../types';
+import { SFFeedbackObj } from '../../types';
 export declare function handleValidation(pFeedbackObj: SFFeedbackObj): void;

package/dist/types/components/internal/SecuredFields/lib/CSF/index.d.ts

@@ -0,0 +1,2 @@
+import csf from './initCSF';
+export default csf;

package/dist/types/components/internal/SecuredFields/lib/{core → CSF}/initCSF.d.ts

@@ -1,3 +1,3 @@
-import { CSFReturnObject, CSFSetupObject } from '../types';
+import { CSFReturnObject, CSFSetupObject } from './types';
 declare const initCSF: (pSetupObj: CSFSetupObject) => CSFReturnObject;
 export default initCSF;

package/dist/types/components/internal/SecuredFields/lib/CSF/partials/handleBinValue.d.ts

@@ -0,0 +1,11 @@
+import { SFFeedbackObj } from '../../types';
+/**
+ * @param csfState - comes from initial, partial, implementation
+ * @param csfCallbacks - comes from initial, partial, implementation
+ *
+ * @param pFeedbackObj -
+ */
+export declare function handleBinValue({ csfState, csfCallbacks }: {
+    csfState: any;
+    csfCallbacks: any;
+}, pFeedbackObj: SFFeedbackObj): void;

package/dist/types/components/internal/SecuredFields/lib/CSF/partials/handleFocus.d.ts

@@ -0,0 +1,15 @@
+import { SFFeedbackObj } from '../../types';
+/**
+ * Call focus callback and store which field currently has focus
+ *
+ * @param csfState - comes from initial, partial, implementation
+ * @param csfProps - comes from initial, partial, implementation
+ * @param csfCallbacks - comes from initial, partial, implementation
+ *
+ * @param pFeedbackObj -
+ */
+export declare function handleFocus({ csfState, csfProps, csfCallbacks }: {
+    csfState: any;
+    csfProps: any;
+    csfCallbacks: any;
+}, pFeedbackObj: SFFeedbackObj): void;

package/dist/types/components/internal/SecuredFields/lib/CSF/partials/handleIframeConfigFeedback.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param csfState - comes from initial, partial, implementation
+ * @param csfCallbacks - comes from initial, partial, implementation
+ * @param isConfigured - comes from initial, partial, implementation
+ *
+ * @param pFeedbackObj -
+ */
+export declare function handleIframeConfigFeedback({ csfState, csfCallbacks }: {
+    csfState: any;
+    csfCallbacks: any;
+}, isConfigured: any, pFeedbackObj: any): boolean;

package/dist/types/components/internal/SecuredFields/lib/CSF/partials/isConfigured.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param csfState - comes from initial, partial, implementation
+ * @param csfConfig - comes from initial, partial, implementation
+ * @param csfProps - comes from initial, partial, implementation
+ * @param csfCallbacks - comes from initial, partial, implementation
+ * @param validateForm - comes from initial, partial, implementation
+ */
+export declare function isConfigured({ csfState, csfConfig, csfProps, csfCallbacks }: {
+    csfState: any;
+    csfConfig: any;
+    csfProps: any;
+    csfCallbacks: any;
+}, validateForm: any): void;

package/dist/types/components/internal/SecuredFields/lib/CSF/partials/postMessageToAllIframes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * UTIL TO BROADCAST TO ALL IFRAMES AT ONCE
+ * Adds correct txVariant, fieldType and numKey for each iframe
+ *
+ * @param csfState - comes from initial, partial, implementation
+ * @param csfConfig  - comes from initial, partial, implementation
+ *
+ * @param pDataObj -
+ */
+export declare function postMessageToAllIframes({ csfState, csfConfig }: {
+    csfState: any;
+    csfConfig: any;
+}, pDataObj: object): void;

package/dist/types/components/internal/SecuredFields/lib/CSF/partials/processAutoComplete.d.ts

@@ -0,0 +1,14 @@
+import { SFFeedbackObj } from '../../types';
+/**
+ *
+ * @param csfState - comes from initial, partial, implementation
+ * @param csfConfig - comes from initial, partial, implementation
+ * @param csfCallbacks - comes from initial, partial, implementation
+ *
+ * @param pFeedbackObj -
+ */
+export declare function processAutoComplete({ csfState, csfConfig, csfCallbacks }: {
+    csfState: any;
+    csfConfig: any;
+    csfCallbacks: any;
+}, pFeedbackObj: SFFeedbackObj): void;

package/dist/types/components/internal/SecuredFields/lib/CSF/partials/processBrand.d.ts

@@ -0,0 +1,20 @@
+import { SFFeedbackObj } from '../../types';
+/**
+ * - If generic card type AND passed brand doesn't equal stored brand - send the new brand to the cvc input
+ *    (so it can reassess what length it should be and if any value it contains is now valid)
+ *
+ * - Create object for onBrand callback aka SFPHandlers.handleOnBrand
+ *
+ * @param csfState - comes from initial, partial, implementation
+ * @param csfConfig - comes from initial, partial, implementation
+ * @param csfProps - comes from initial, partial, implementation
+ * @param csfCallbacks - comes from initial, partial, implementation
+ *
+ * @param pFeedbackObj -
+ */
+export default function processBrand({ csfState, csfConfig, csfProps, csfCallbacks }: {
+    csfState: any;
+    csfConfig: any;
+    csfProps: any;
+    csfCallbacks: any;
+}, pFeedbackObj: SFFeedbackObj): boolean;

package/dist/types/components/internal/SecuredFields/lib/CSF/partials/setFocusOnFrame.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param csfState - comes from initial, partial, implementation
+ * @param csfConfig - comes from initial, partial, implementation
+ *
+ * @param pFieldType -
+ * @param doLog -
+ */
+export declare function setFocusOnFrame({ csfState, csfConfig }: {
+    csfState: any;
+    csfConfig: any;
+}, pFieldType: string, doLog?: boolean): void;

package/dist/types/components/internal/SecuredFields/lib/CSF/partials/validateForm.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param csfState - comes from initial, partial, implementation
+ * @param csfProps - comes from initial, partial, implementation
+ * @param csfCallbacks - comes from initial, partial, implementation
+ */
+export default function validateForm({ csfState, csfProps, csfCallbacks }: {
+    csfState: any;
+    csfProps: any;
+    csfCallbacks: any;
+}): void;

package/dist/types/components/internal/SecuredFields/lib/CSF/types.d.ts

@@ -0,0 +1,83 @@
+import Language from '../../../../../language/Language';
+import { BrandStorageObject } from '../types';
+/**
+ * Exposed functions that can be called on the CSF instance
+ */
+export interface CSFReturnObject {
+    updateStyles: any;
+    setFocusOnFrame: any;
+    isValidated: any;
+    destroy: any;
+    brandsFromBinLookup: any;
+    hasUnsupportedCard: any;
+    addSecuredField: any;
+    removeSecuredField: any;
+    setKCPStatus: any;
+    sendValueToFrame?: any;
+}
+/**
+ * Base interface for SetupObject & ConfigObject
+ */
+interface CSFCommonProps {
+    loadingContext: string;
+    cardGroupTypes?: string[];
+    allowedDOMAccess?: boolean;
+    autoFocus?: boolean;
+    trimTrailingSeparator?: boolean;
+    showWarnings?: boolean;
+    keypadFix?: boolean;
+    isKCP?: boolean;
+    iframeUIConfig?: object;
+    legacyInputMode?: boolean;
+    minimumExpiryDate?: string;
+    implementationType?: 'components' | 'custom';
+    isCollatingErrors?: boolean;
+}
+/**
+ * Object sent when SecuredFieldsProvider initialises CSF
+ */
+export interface CSFSetupObject extends CSFCommonProps {
+    type: string;
+    clientKey: string;
+    rootNode: string | HTMLElement;
+    callbacks?: object;
+    i18n?: Language;
+}
+/**
+ * The type for the config object created by CSF: properties that just need to be set once, at startup, and then don't change
+ * This object provides the source for many of the properties that are written into the SFSetupObject used to initialise a new SecuredField.ts
+ */
+export interface CSFConfigObject extends CSFCommonProps {
+    iframeSrc: string;
+    isCreditCardType: boolean;
+    sfLogAtStart: boolean;
+}
+export interface CSFCallbacksConfig {
+    onLoad?: (callbackObj: object) => void;
+    onConfigSuccess?: (callbackObj: object) => void;
+    onFieldValid?: (callbackObj: object) => void;
+    onAllValid?: (callbackObj: object) => void;
+    onBrand?: (callbackObj: object) => void;
+    onError?: (callbackObj: object) => void;
+    onFocus?: (callbackObj: object) => void;
+    onBinValue?: (callbackObj: object) => void;
+    onAutoComplete?: (callbackObj: object) => void;
+    onAdditionalSFConfig?: (callbackObj: object) => void;
+    onAdditionalSFRemoved?: (callbackObj: object) => void;
+}
+export interface CSFStateObject {
+    type: string;
+    brand: BrandStorageObject;
+    allValid: boolean;
+    numIframes: number;
+    originalNumIframes: number;
+    iframeCount: number;
+    iframeConfigCount: number;
+    isConfigured: boolean;
+    hasSeparateDateFields: boolean;
+    currentFocusObject: string;
+    registerFieldForIos: boolean;
+    securedFields: object;
+    isKCP: boolean;
+}
+export {};