@basis-theory/react-elements 1.11.2 → 1.11.4

package/types/index.d.ts

@@ -0,0 +1,682 @@
+import { Properties } from "csstype";
+import React, { PropsWithChildren, MutableRefObject } from "react";
+type CardBrandId = 'american-express' | 'diners-club' | 'discover' | 'elo' | 'hiper' | 'hipercard' | 'jcb' | 'maestro' | 'mastercard' | 'mir' | 'unionpay' | 'visa';
+type CardBrandNiceType = 'American Express' | 'Diners Club' | 'Discover' | 'Elo' | 'Hiper' | 'Hipercard' | 'JCB' | 'Maestro' | 'Mastercard' | 'Mir' | 'UnionPay' | 'Visa';
+type SecurityCodeLabel = 'CVV' | 'CVC' | 'CID' | 'CVN' | 'CVE' | 'CVP2';
+export type CreditCardType = {
+    code: {
+        size: number;
+        name: SecurityCodeLabel | string;
+    };
+    gaps: number[];
+    lengths: number[];
+    niceType: CardBrandNiceType | string;
+    patterns: (number | [number, number])[];
+    type: CardBrandId | string;
+};
+export const VISA: CreditCardType;
+export const MASTERCARD: CreditCardType;
+export const AMERICAN_EXPRESS: CreditCardType;
+export const DINERS_CLUB: CreditCardType;
+export const DISCOVER: CreditCardType;
+export const JCB: CreditCardType;
+export const UNION_PAY: CreditCardType;
+export const MAESTRO: CreditCardType;
+export const ELO: CreditCardType;
+export const MIR: CreditCardType;
+export const HIPER: CreditCardType;
+export const HIPERCARD: CreditCardType;
+export const DEFAULT_CARD_TYPES: CreditCardType[];
+export interface RequestConfig {
+    headers?: Record<string, string>;
+}
+export interface HttpClient {
+    post(url: string, payload: unknown, config?: RequestConfig): Promise<unknown>;
+    put(url: string, payload: unknown, config?: RequestConfig): Promise<unknown>;
+    patch(url: string, payload: unknown, config?: RequestConfig): Promise<unknown>;
+    get(url: string, config?: RequestConfig): Promise<unknown>;
+    delete(url: string, config?: RequestConfig): Promise<unknown>;
+}
+export const CARD_BRANDS: readonly ["visa", "mastercard", "american-express", "discover", "diners-club", "jcb", "unionpay", "maestro", "elo", "hiper", "hipercard", "mir", "unknown"];
+declare const CARD_ICON_POSITIONS: readonly ["left", "right", "none"];
+declare const AUTOCOMPLETE_VALUES: readonly ["additional-name", "address-level1", "address-level2", "address-level3", "address-level4", "address-line1", "address-line2", "address-line3", "bday-day", "bday-month", "bday-year", "bday", "billing", "cc-additional-name", "cc-csc", "cc-exp-month", "cc-exp-year", "cc-exp", "cc-family-name", "cc-given-name", "cc-name", "cc-number", "cc-type", "country-name", "country", "current-password", "email", "family-name", "fax", "given-name", "home", "honorific-prefix", "honorific-suffix", "language", "mobile", "name", "new-password", "nickname", "off", "on", "one-time-code", "organization-title", "organization", "page", "postal-code", "sex", "shipping", "street-address", "tel-area-code", "tel-country-code", "tel-extension", "tel-local-prefix", "tel-local-suffix", "tel-local", "tel-national", "tel", "transaction-amount", "transaction-currency", "url", "username", "work"];
+export type FieldErrorType = 'incomplete' | 'invalid';
+export type ConfigErrorType = 'missing-configuration' | 'missing-permission' | 'invalid-configuration';
+export interface ConfigError {
+    type: ConfigErrorType;
+    message: string;
+}
+export interface Targeted {
+    targetId: string;
+}
+export type ListenableKey = 'Escape' | 'Enter';
+export interface FieldError {
+    targetId: string;
+    type: FieldErrorType;
+}
+export interface PropertyError {
+    type: FieldErrorType;
+}
+export interface ElementMetadata {
+    complete: boolean;
+    valid: boolean;
+    maskSatisfied?: boolean;
+    empty: boolean;
+    errors?: FieldError[] | Omit<FieldError, 'targetId'>[];
+}
+export interface CardMetadata {
+    cardBrand: Brand;
+    cardLast4?: string;
+    cardBin?: string;
+}
+/**
+ * Card brands type
+ */
+export type Brand = (typeof CARD_BRANDS)[number];
+/**
+ * Icon position for card number element
+ */
+export type CardIconPosition = (typeof CARD_ICON_POSITIONS)[number];
+/**
+ * Values for the element input autocomplete attribute
+ */
+export type AutoCompleteValue = (typeof AUTOCOMPLETE_VALUES)[number];
+/**
+ * Type used for detokenization responses stored on Data Elements
+ */
+export type DataElementReference = {
+    correlationId: string;
+    elementId: string;
+    path: string;
+};
+export type EventType = 'ready' | 'change' | 'focus' | 'blur' | 'keydown';
+export interface BaseEvent<T extends EventType> {
+    type: T;
+}
+export type ReadyEvent = BaseEvent<'ready'>;
+export type ChangeEvent = BaseEvent<'change'> & {
+    empty: boolean;
+    complete: boolean;
+    valid?: boolean;
+    maskSatisfied?: boolean;
+    errors?: FieldError[];
+};
+export type CardChangeEvent = ChangeEvent & {
+    cardBrand: Brand;
+    cardLast4?: string;
+    cardBin?: string;
+};
+export type InputFocusEvent = BaseEvent<'focus'> & Targeted;
+export type InputBlurEvent = BaseEvent<'blur'> & Targeted;
+export type InputKeydownEvent = BaseEvent<'keydown'> & Targeted & {
+    key: ListenableKey;
+} & Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'shiftKey' | 'metaKey'>;
+export type BaseElementEvents = ReadyEvent | InputFocusEvent | InputBlurEvent | InputKeydownEvent;
+export type TextElementEvents = BaseElementEvents | ChangeEvent;
+export type CardElementEvents = BaseElementEvents | CardChangeEvent;
+export type CardNumberElementEvents = BaseElementEvents | CardChangeEvent;
+export type CardExpirationDateElementEvents = BaseElementEvents | ChangeEvent;
+export type CardVerificationCodeElementEvents = BaseElementEvents | ChangeEvent;
+/**
+ * Utility type that helps find a Union type based on a `type` property
+ */
+type FindByType<Union, Type> = Union extends {
+    type: Type;
+} ? Union : never;
+export type ElementEventListener<Events, Type> = (event: FindByType<Events, Type>) => void;
+export interface Subscription {
+    unsubscribe(): void;
+}
+export const SAFE_CSS_PROPERTIES: readonly ["backgroundColor", "color", "fontFamily", "fontSize", "fontSmooth", "fontStyle", "fontVariant", "fontWeight", "lineHeight", "letterSpacing", "textAlign", "padding", "textDecoration", "textShadow", "textTransform"];
+export type SafeCSSProperty = (typeof SAFE_CSS_PROPERTIES)[number];
+export const SAFE_CSS_PROPERTIES_ALTERNATES: Partial<Record<SafeCSSProperty, string[]>>;
+export const SAFE_CSS_PROPERTIES_WITH_ALTERNATES: string[];
+export type SafeStyle = Pick<Properties, SafeCSSProperty>;
+export const CARD_ELEMENT_STYLE_VARIANT_SELECTORS: readonly [":hover", ":focus", ":read-only", "::placeholder", "::selection", ":disabled"];
+export type CardElementStyleVariantSelector = (typeof CARD_ELEMENT_STYLE_VARIANT_SELECTORS)[number];
+export type CardElementStyleVariantStyle = SafeStyle & Partial<Record<CardElementStyleVariantSelector, SafeStyle>>;
+export const CARD_ELEMENT_STYLE_VARIANTS: readonly ["base", "complete", "invalid", "empty"];
+export const CARD_ELEMENT_STYLE_FONTS_ATTR: "fonts";
+export type CardElementStyleVariant = (typeof CARD_ELEMENT_STYLE_VARIANTS)[number];
+type CardElementStyleFontAttr = typeof CARD_ELEMENT_STYLE_FONTS_ATTR;
+type FontSource = string;
+export type FontSources = FontSource[];
+export type Fonts = Record<CardElementStyleFontAttr, FontSources>;
+export type CardElementStyle = Partial<Record<CardElementStyleVariant, CardElementStyleVariantStyle> & Fonts>;
+export type ElementStyle = CardElementStyle;
+export type CopyIconStyles = {
+    size?: string;
+    color?: string;
+    successColor?: string;
+};
+export const ELEMENTS_TYPES: readonly ["card", "cardExpirationDate", "cardNumber", "cardVerificationCode", "data", "text"];
+export type ElementType = (typeof ELEMENTS_TYPES)[number];
+export interface ElementInternalOptions {
+    apiKey: string | undefined;
+    baseUrl: string;
+    type: ElementType;
+    useNgApi: boolean | undefined;
+    useSameOriginApi: boolean | undefined;
+}
+export enum InputMode {
+    DECIMAL = "decimal",
+    EMAIL = "email",
+    NONE = "none",
+    NUMERIC = "numeric",
+    SEARCH = "search",
+    TEL = "tel",
+    TEXT = "text",
+    URL = "url"
+}
+export interface SanitizedElementOptions {
+    ariaDescription?: string;
+    ariaLabel?: string;
+    autoComplete?: AutoCompleteValue;
+    cardBrand?: string;
+    cardTypes?: CreditCardType[];
+    copyIconStyles?: CopyIconStyles;
+    disabled?: boolean;
+    enableCopy?: boolean;
+    iconPosition?: string;
+    inputMode?: `${InputMode}`;
+    mask?: (RegExp | string)[];
+    maxLength?: HTMLInputElement['maxLength'];
+    password?: boolean;
+    placeholder?: string;
+    readOnly?: boolean;
+    skipLuhnValidation?: boolean;
+    style?: ElementStyle;
+    targetId?: string;
+    transform?: [RegExp, string] | null;
+    validateOnChange?: boolean;
+    validation?: RegExp;
+    value?: CardElementValue<'static'> | CardExpirationDateValue<'static'> | string;
+}
+export type ElementOptions = ElementInternalOptions & SanitizedElementOptions;
+export type Transform = RegExp | [RegExp, string?] | null;
+interface TransformOption {
+    transform?: Transform;
+}
+interface AutoCompleteOption {
+    autoComplete?: AutoCompleteValue;
+}
+export type CustomizableElementOptions = Pick<ElementOptions, 'cardTypes' | 'copyIconStyles' | 'disabled' | 'enableCopy' | 'inputMode' | 'readOnly' | 'skipLuhnValidation' | 'style' | 'validateOnChange'> & AutoCompleteOption;
+type ElementValueType = 'static' | 'reference';
+export interface CardElementValue<T extends ElementValueType> {
+    cvc?: T extends 'reference' ? DataElementReference : string;
+    expiration_month?: T extends 'reference' ? DataElementReference : number;
+    expiration_year?: T extends 'reference' ? DataElementReference : number;
+    number?: T extends 'reference' ? DataElementReference : string;
+}
+export interface CardElementPlaceholder {
+    cardNumber?: string;
+    cardExpirationDate?: string;
+    cardSecurityCode?: string;
+}
+export interface CardExpirationDateValue<T extends ElementValueType> {
+    month: T extends 'reference' ? DataElementReference : number;
+    year: T extends 'reference' ? DataElementReference : number;
+}
+export type CreateCardElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'cardTypes' | 'skipLuhnValidation'> & {
+    placeholder?: CardElementPlaceholder;
+    value?: CardElementValue<'static'>;
+};
+export type UpdateCardElementOptions = Omit<CreateCardElementOptions, 'validateOnChange' | 'enableCopy'>;
+export type CreateTextElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder' | 'mask' | 'maxLength' | 'password' | 'validation'> & TransformOption & Required<Pick<ElementOptions, 'targetId'>> & {
+    'aria-label'?: string;
+    value?: string;
+};
+export type UpdateTextElementOptions = Omit<CreateTextElementOptions, 'targetId' | 'mask' | 'validateOnChange'>;
+export type CreateCardNumberElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder' | 'iconPosition' | 'cardTypes' | 'skipLuhnValidation'> & Required<Pick<ElementOptions, 'targetId'>> & {
+    'aria-label'?: string;
+    value?: string;
+};
+export type UpdateCardNumberElementOptions = Omit<CreateCardNumberElementOptions, 'targetId' | 'validateOnChange' | 'enableCopy'>;
+export type CreateCardExpirationDateElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder'> & Required<Pick<ElementOptions, 'targetId'>> & {
+    'aria-label'?: string;
+    value?: CardExpirationDateValue<'static'> | string;
+};
+export type UpdateCardExpirationDateElementOptions = Omit<CreateCardExpirationDateElementOptions, 'targetId' | 'validateOnChange' | 'enableCopy'>;
+export type CreateCardVerificationCodeElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder' | 'cardBrand'> & Required<Pick<ElementOptions, 'targetId'>> & {
+    'aria-label'?: string;
+    value?: string;
+};
+export type UpdateCardVerificationCodeElementOptions = Omit<CreateCardVerificationCodeElementOptions, 'targetId' | 'validateOnChange' | 'enableCopy'>;
+export interface BinDetails {
+    cardBrand?: string;
+    type?: string;
+    prepaid?: boolean;
+    cardSegmentType?: string;
+    reloadable?: boolean;
+    panOrToken?: string;
+    accountUpdater?: boolean;
+    alm?: boolean;
+    domesticOnly?: boolean;
+    gamblingBlocked?: boolean;
+    level2?: boolean;
+    level3?: boolean;
+    issuerCurrency?: string;
+    comboCard?: string;
+    binLength?: number;
+    authentication?: unknown;
+    cost?: unknown;
+    bank?: BinDetailsBank;
+    country?: BinDetailsCountry;
+    product?: BinDetailsProduct;
+}
+export interface BinDetailsBank {
+    name?: string;
+    phone?: string;
+    url?: string;
+    cleanName?: string;
+}
+export interface BinDetailsCountry {
+    alpha2?: string;
+    name?: string;
+    numeric?: string;
+}
+export interface BinDetailsProduct {
+    code?: string;
+    name?: string;
+}
+export type Primitive = string | number | boolean | null;
+export type TokenType = 'token' | 'card' | 'bank' | 'card_number' | 'us_bank_routing_number' | 'us_bank_account_number' | 'social_security_number';
+export interface Auditable {
+    createdBy?: string;
+    createdAt?: string;
+    modifiedBy?: string;
+    modifiedAt?: string;
+}
+export type DataObject<DataType = Primitive> = {
+    [member: string]: TokenData<DataType>;
+};
+type DataArray<DataType> = Array<TokenData<DataType>>;
+type TokenData<DataType = Primitive> = Primitive | DataObject<DataType> | DataArray<DataType> | DataType;
+export interface TokenBase<DataType = Primitive> extends Auditable {
+    data: TokenData<DataType>;
+    type: TokenType;
+}
+export interface ReactResponse {
+    tokens: DataObject;
+    raw: DataObject;
+}
+export const DATA_CLASSIFICATIONS: readonly ["general", "bank", "pci", "pii"];
+export type DataClassification = (typeof DATA_CLASSIFICATIONS)[number];
+export const DATA_IMPACT_LEVELS: readonly ["low", "moderate", "high"];
+export type DataImpactLevel = (typeof DATA_IMPACT_LEVELS)[number];
+export const DATA_RESTRICTION_POLICIES: readonly ["mask", "redact"];
+export type DataRestrictionPolicy = (typeof DATA_RESTRICTION_POLICIES)[number];
+type MaskObject = {
+    [member: string]: TokenMask;
+};
+type MaskArray = Array<TokenMask>;
+type TokenMask = string | null | MaskObject | MaskArray;
+interface TokenEncryptionKey {
+    key: string;
+    alg: string;
+}
+interface TokenEncryption {
+    cek: TokenEncryptionKey;
+    kek: TokenEncryptionKey;
+}
+interface TokenPrivacy {
+    classification?: DataClassification;
+    impactLevel?: DataImpactLevel;
+    restrictionPolicy?: DataRestrictionPolicy;
+}
+export interface TokenEnrichments {
+    binDetails?: BinDetails;
+}
+export type Token<DataType = Primitive> = TokenBase<DataType> & {
+    id: string;
+    privacy?: TokenPrivacy;
+    containers?: string[];
+    encryption?: TokenEncryption;
+    searchIndexes?: string[];
+    fingerprintExpression?: string;
+    mask?: TokenMask;
+    expiresAt?: string;
+    enrichments?: TokenEnrichments;
+    tenantId: string;
+    fingerprint?: string;
+    metadata?: Record<string, string>;
+};
+export type CreateTokenModel<DataType = Primitive> = Pick<Token<DataType>, 'type' | 'data' | 'privacy' | 'containers' | 'metadata' | 'encryption' | 'searchIndexes' | 'fingerprintExpression' | 'mask' | 'expiresAt'> & {
+    deduplicateToken?: boolean;
+    id?: string;
+};
+export type UpdateTokenModel<DataType = Primitive> = Partial<Pick<Token<DataType>, 'data' | 'containers' | 'metadata' | 'encryption' | 'searchIndexes' | 'fingerprintExpression' | 'mask' | 'expiresAt'> & {
+    privacy: Omit<TokenPrivacy, 'classification'>;
+    deduplicateToken: boolean;
+}>;
+export type TokenizeObject<DataType = Primitive> = {
+    [key: string]: Primitive | TokenizeObject<DataType> | TokenizeArray<DataType> | DataType;
+};
+export type TokenizeArray<DataType = Primitive> = Array<Primitive | TokenizeObject<DataType> | TokenizeArray<DataType> | DataType>;
+export type TokenizeDataModel<DataType = Primitive> = TokenizeArray<DataType> | TokenizeObject<DataType>;
+export interface Card {
+    number: string;
+    expirationMonth?: number;
+    expirationYear?: number;
+    cvc?: string;
+}
+export interface IssuerCountry {
+    alpha2: string;
+    name: string;
+    numeric: string;
+}
+/**
+ * Make all properties in T nullable
+ */
+export type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+/**
+ * Make selected properties in T nullable
+ */
+export type NullableProps<T, K extends keyof T> = T | Nullable<Pick<T, K>>;
+export interface TokenIntentCardDetails {
+    type: 'card';
+    card: {
+        bin: string;
+        last4: string;
+        brand: string;
+        funding: string;
+        expirationMonth: number;
+        expirationYear: number;
+        issuerCountry?: IssuerCountry;
+    };
+}
+interface TokenIntentBankDetails {
+    type: 'bank';
+    bank: {
+        routingNumber: string;
+        accountNumberLast4: string;
+    };
+}
+type TokenTypesForTokenIntents = Exclude<TokenType, 'token' | 'card' | 'bank'>;
+type TokenTypeMap = {
+    [K in TokenTypesForTokenIntents]: {
+        type: K;
+    } & Record<K, Record<string, unknown>>;
+};
+export type TokenIntent<DataType = DataObject> = (TokenBase<DataType> & Omit<Auditable, 'modifiedAt' | 'modifiedBy'> & {
+    id: string;
+    tenantId: string;
+    expiresAt: string;
+    fingerprint?: string;
+}) & (TokenTypeMap[TokenTypesForTokenIntents] | TokenIntentCardDetails | TokenIntentBankDetails | {
+    type: 'token';
+});
+export type CreateTokenIntentModel<DataType = DataObject> = Pick<TokenIntent<DataType>, 'type' | 'data'>;
+interface RequestOptions {
+    apiKey?: string;
+    correlationId?: string;
+    idempotencyKey?: string;
+}
+type Create<T, C> = {
+    create(model: C, options?: RequestOptions): Promise<T>;
+};
+type Retrieve<T> = {
+    retrieve(id: string, options?: RequestOptions): Promise<T>;
+};
+type Update<T, U> = {
+    update(id: string, model: U, options?: RequestOptions): Promise<T>;
+};
+export type TokenizeData = TokenizeDataModel<ElementValue>;
+export interface Tokenize {
+    tokenize(tokens: TokenizeData, options?: RequestOptions): Promise<TokenizeDataModel>;
+}
+export type CreateToken = CreateTokenModel<ElementValue>;
+export type UpdateToken = UpdateTokenModel<ElementValue>;
+export type Tokens = Create<Token, CreateToken> & Retrieve<Token<any>> & Update<Token, UpdateToken>;
+type BasisTheoryProxyHeaders = {
+    [key: string]: string;
+    'BT-PROXY-URL': string;
+    'BT-PROXY-KEY': string;
+};
+type ProxyHeaders = Partial<BasisTheoryProxyHeaders>;
+type BasisTheoryQueryParams = {
+    [key: string]: string;
+    'bt-proxy-key': string;
+};
+type ProxyQuery = Partial<BasisTheoryQueryParams>;
+export interface ProxyRequestOptions extends RequestOptions {
+    includeResponseHeaders?: boolean;
+    path?: string;
+    query?: ProxyQuery;
+    headers?: ProxyHeaders;
+    body?: unknown;
+}
+export interface Proxy {
+    get(options?: ProxyRequestOptions): Promise<unknown>;
+    post(options?: ProxyRequestOptions): Promise<unknown>;
+    patch(options?: ProxyRequestOptions): Promise<unknown>;
+    put(options?: ProxyRequestOptions): Promise<unknown>;
+    delete(options?: ProxyRequestOptions): Promise<unknown>;
+}
+export type CreateTokenIntent = CreateTokenIntentModel<ElementValue>;
+export type TokenIntents = Create<TokenIntent, CreateTokenIntent>;
+type CreateSessionResponse = {
+    sessionKey: string;
+    nonce: string;
+    expiresAt: string;
+    _debug?: Record<string, unknown>;
+};
+interface Sessions {
+    create(options?: RequestOptions): Promise<CreateSessionResponse>;
+}
+export interface BaseElement<UpdateOptions, ElementEvents> {
+    readonly mounted: boolean;
+    readonly metadata: ElementMetadata;
+    mount(selector: string): Promise<void>;
+    mount(element: Element): Promise<void>;
+    update(options: UpdateOptions): Promise<void>;
+    clear(): void;
+    focus(): void;
+    blur(): void;
+    unmount(): void;
+    on<T extends EventType>(eventType: T, listener: ElementEventListener<ElementEvents, T>): Subscription;
+}
+export type ICardElement = BaseElement<UpdateCardElementOptions, CardElementEvents> & {
+    readonly cardMetadata?: CardMetadata;
+    setValue(value: CardElementValue<'reference'>): void;
+    validate(): void;
+};
+export type ITextElement = BaseElement<UpdateTextElementOptions, TextElementEvents> & {
+    setValueRef(value: ITextElement): void;
+    setValue(value: DataElementReference): void;
+};
+export type ICardNumberElement = BaseElement<UpdateCardNumberElementOptions, CardNumberElementEvents> & {
+    readonly cardMetadata?: CardMetadata;
+    setValueRef(value: ICardNumberElement): void;
+    setValue(value: DataElementReference): void;
+};
+export type ICardExpirationDateElement = BaseElement<UpdateCardExpirationDateElementOptions, CardExpirationDateElementEvents> & {
+    setValueRef(value: ICardExpirationDateElement): void;
+    setValue(value: CardExpirationDateValue<'reference'>): void;
+    month(): ElementWrapper<ICardExpirationDateElement>;
+    year(): ElementWrapper<ICardExpirationDateElement>;
+    format(dateFormat: string): ElementWrapper<ICardExpirationDateElement>;
+};
+export type ICardVerificationCodeElement = BaseElement<UpdateCardVerificationCodeElementOptions, CardVerificationCodeElementEvents> & {
+    setValueRef(value: ICardVerificationCodeElement): void;
+    setValue(value: DataElementReference): void;
+};
+export type ElementWrapper<T extends BaseElement<any, any> = BaseElement<any, any>> = {
+    element: T;
+    method?: string;
+    formattingOptions?: {
+        format: string;
+    };
+};
+export type ElementValue = ITextElement | ICardElement | ICardNumberElement | ICardExpirationDateElement | ICardVerificationCodeElement | ElementWrapper;
+export interface BasisTheoryElements {
+    tokens: Tokens;
+    proxy: Proxy;
+    sessions: Sessions;
+    tokenIntents: TokenIntents;
+    tokenize: Tokenize['tokenize'];
+    client: HttpClient;
+    createElement(type: 'card', options?: CreateCardElementOptions): ICardElement;
+    createElement(type: 'text', options: CreateTextElementOptions): ITextElement;
+    createElement(type: 'cardNumber', options: CreateCardNumberElementOptions): ICardNumberElement;
+    createElement(type: 'cardExpirationDate', options: CreateCardExpirationDateElementOptions): ICardExpirationDateElement;
+    createElement(type: 'cardVerificationCode', options: CreateCardVerificationCodeElementOptions): ICardVerificationCodeElement;
+}
+export interface BasisTheoryElementsInternal extends BasisTheoryElements {
+    init: (apiKey: string | undefined, elementsBaseUrl: string, elementsUseNgApi: boolean | undefined, elementsUseSameOriginApi: boolean | undefined, disableTelemetry: boolean | undefined, debug: boolean | undefined) => Promise<BasisTheoryElements>;
+    hasElement: (payload: unknown) => boolean;
+}
+declare global {
+    interface Window {
+        BasisTheoryElements?: BasisTheoryElementsInternal;
+    }
+}
+export interface BasisTheoryInitOptions {
+    _devMode?: boolean;
+    disableTelemetry?: boolean;
+    useSameOriginApi?: boolean;
+    debug?: boolean;
+}
+export const basistheory: (apiKey: string, options?: BasisTheoryInitOptions) => Promise<BasisTheoryElements | undefined>;
+declare global {
+    interface Window {
+        basistheory?: typeof basistheory;
+    }
+}
+interface BasisTheoryProviderProps {
+    bt?: BasisTheoryElements;
+}
+export const BasisTheoryProvider: ({ bt, children, }: PropsWithChildren<BasisTheoryProviderProps>) => JSX.Element;
+export const useBasisTheory: (apiKey?: string, options?: BasisTheoryInitOptions) => {
+    bt: BasisTheoryElements | undefined;
+    error: Error | undefined;
+} | {
+    bt: BasisTheoryElements | undefined;
+    error?: undefined;
+};
+export interface CardElementProps {
+    autoComplete?: CreateCardElementOptions['autoComplete'];
+    bt?: BasisTheoryElements;
+    cardTypes?: CreditCardType[];
+    copyIconStyles?: CopyIconStyles;
+    disabled?: boolean;
+    enableCopy?: boolean;
+    id: string;
+    inputMode?: `${InputMode}`;
+    onBlur?: ElementEventListener<CardElementEvents, 'blur'>;
+    onChange?: ElementEventListener<CardElementEvents, 'change'>;
+    onFocus?: ElementEventListener<CardElementEvents, 'focus'>;
+    onKeyDown?: ElementEventListener<CardElementEvents, 'keydown'>;
+    onReady?: ElementEventListener<CardElementEvents, 'ready'>;
+    placeholder?: CardElementPlaceholder;
+    readOnly?: boolean;
+    skipLuhnValidation?: boolean;
+    style?: ElementStyle;
+    validateOnChange?: boolean;
+    value?: CardElementValue<'static'>;
+}
+export const CardElement: React.ForwardRefExoticComponent<CardElementProps & React.RefAttributes<ICardElement>>;
+interface BaseTextElementProps {
+    'aria-label'?: string;
+    autoComplete?: CreateTextElementOptions['autoComplete'];
+    bt?: BasisTheoryElements;
+    disabled?: boolean;
+    id: string;
+    inputMode?: `${InputMode}`;
+    maxLength?: HTMLInputElement['maxLength'];
+    onBlur?: ElementEventListener<TextElementEvents, 'blur'>;
+    onChange?: ElementEventListener<TextElementEvents, 'change'>;
+    onFocus?: ElementEventListener<TextElementEvents, 'focus'>;
+    onKeyDown?: ElementEventListener<TextElementEvents, 'keydown'>;
+    onReady?: ElementEventListener<TextElementEvents, 'ready'>;
+    placeholder?: string;
+    readOnly?: boolean;
+    style?: ElementStyle;
+    transform?: RegExp | [RegExp, string?];
+    validateOnChange?: boolean;
+    validation?: RegExp;
+    value?: string;
+    valueRef?: MutableRefObject<ITextElement | null>;
+}
+interface MaskedTextElementProps extends BaseTextElementProps {
+    mask?: (RegExp | string)[];
+    password?: false;
+}
+interface PasswordTextElementProps extends BaseTextElementProps {
+    mask?: never;
+    password: true;
+}
+export type TextElementProps = MaskedTextElementProps | PasswordTextElementProps;
+export const TextElement: React.ForwardRefExoticComponent<TextElementProps & React.RefAttributes<ITextElement>>;
+export interface CardNumberElementProps {
+    'aria-label'?: string;
+    autoComplete?: CreateCardNumberElementOptions['autoComplete'];
+    bt?: BasisTheoryElements;
+    cardTypes?: CreditCardType[];
+    copyIconStyles?: CopyIconStyles;
+    disabled?: boolean;
+    enableCopy?: boolean;
+    iconPosition?: SanitizedElementOptions['iconPosition'];
+    id: string;
+    inputMode?: `${InputMode}`;
+    onBlur?: ElementEventListener<CardNumberElementEvents, 'blur'>;
+    onChange?: ElementEventListener<CardNumberElementEvents, 'change'>;
+    onFocus?: ElementEventListener<CardNumberElementEvents, 'focus'>;
+    onKeyDown?: ElementEventListener<CardNumberElementEvents, 'keydown'>;
+    onReady?: ElementEventListener<CardNumberElementEvents, 'ready'>;
+    placeholder?: string;
+    readOnly?: boolean;
+    skipLuhnValidation?: boolean;
+    style?: ElementStyle;
+    validateOnChange?: boolean;
+    value?: string;
+    valueRef?: MutableRefObject<ICardNumberElement | null>;
+}
+export const CardNumberElement: React.ForwardRefExoticComponent<CardNumberElementProps & React.RefAttributes<ICardNumberElement>>;
+export interface CardExpirationDateElementProps {
+    'aria-label'?: string;
+    autoComplete?: CreateCardExpirationDateElementOptions['autoComplete'];
+    bt?: BasisTheoryElements;
+    copyIconStyles?: CopyIconStyles;
+    disabled?: boolean;
+    enableCopy?: boolean;
+    id: string;
+    inputMode?: `${InputMode}`;
+    onBlur?: ElementEventListener<CardExpirationDateElementEvents, 'blur'>;
+    onChange?: ElementEventListener<CardExpirationDateElementEvents, 'change'>;
+    onFocus?: ElementEventListener<CardExpirationDateElementEvents, 'focus'>;
+    onKeyDown?: ElementEventListener<CardExpirationDateElementEvents, 'keydown'>;
+    onReady?: ElementEventListener<CardExpirationDateElementEvents, 'ready'>;
+    placeholder?: string;
+    readOnly?: boolean;
+    style?: ElementStyle;
+    validateOnChange?: boolean;
+    value?: CardExpirationDateValue<'static'> | string;
+    valueRef?: MutableRefObject<ICardExpirationDateElement | null>;
+}
+export const CardExpirationDateElement: React.ForwardRefExoticComponent<CardExpirationDateElementProps & React.RefAttributes<ICardExpirationDateElement>>;
+export interface CardVerificationCodeElementProps {
+    'aria-label'?: string;
+    autoComplete?: CreateCardVerificationCodeElementOptions['autoComplete'];
+    bt?: BasisTheoryElements;
+    cardBrand?: Brand | string;
+    copyIconStyles?: CopyIconStyles;
+    disabled?: boolean;
+    enableCopy?: boolean;
+    id: string;
+    inputMode?: `${InputMode}`;
+    onBlur?: ElementEventListener<CardVerificationCodeElementEvents, 'blur'>;
+    onChange?: ElementEventListener<CardVerificationCodeElementEvents, 'change'>;
+    onFocus?: ElementEventListener<CardVerificationCodeElementEvents, 'focus'>;
+    onKeyDown?: ElementEventListener<CardVerificationCodeElementEvents, 'keydown'>;
+    onReady?: ElementEventListener<CardVerificationCodeElementEvents, 'ready'>;
+    placeholder?: string;
+    readOnly?: boolean;
+    style?: ElementStyle;
+    validateOnChange?: boolean;
+    value?: string;
+    valueRef?: MutableRefObject<ICardVerificationCodeElement | null>;
+}
+export const CardVerificationCodeElement: React.ForwardRefExoticComponent<CardVerificationCodeElementProps & React.RefAttributes<ICardVerificationCodeElement>>;