@basis-theory/react-elements 1.5.0 → 1.7.2

package/dist/types/react-elements/src/elements/CardExpirationDateElement.d.ts

@@ -0,0 +1,26 @@
+import React, { MutableRefObject } from 'react';
+import type { CardExpirationDateElement as ICardExpirationDateElement, CreateCardExpirationDateElementOptions, ElementEventListener, ElementStyle, CardExpirationDateElementEvents, CardExpirationDateValue, InputMode, CopyIconStyles } from '@basis-theory/basis-theory-js/types/elements';
+import type { BasisTheoryElements } from '@basis-theory/web-elements';
+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 declare const CardExpirationDateElement: React.ForwardRefExoticComponent<CardExpirationDateElementProps & React.RefAttributes<ICardExpirationDateElement>>;
+export type { CardExpirationDateElementProps };

package/dist/types/react-elements/src/elements/CardNumberElement.d.ts

@@ -0,0 +1,29 @@
+import React, { MutableRefObject } from 'react';
+import type { CardNumberElement as ICardNumberElement, CreateCardNumberElementOptions, ElementEventListener, ElementStyle, CardNumberElementEvents, SanitizedElementOptions, InputMode, CreditCardType, CopyIconStyles } from '@basis-theory/basis-theory-js/types/elements';
+import type { BasisTheoryElements } from '@basis-theory/web-elements';
+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 declare const CardNumberElement: React.ForwardRefExoticComponent<CardNumberElementProps & React.RefAttributes<ICardNumberElement>>;
+export type { CardNumberElementProps };

package/dist/types/react-elements/src/elements/CardVerificationCodeElement.d.ts

@@ -0,0 +1,27 @@
+import React, { MutableRefObject } from 'react';
+import type { CardVerificationCodeElement as ICardVerificationCodeElement, CreateCardVerificationCodeElementOptions, ElementEventListener, ElementStyle, CardVerificationCodeElementEvents, Brand, InputMode, CopyIconStyles } from '@basis-theory/basis-theory-js/types/elements';
+import type { BasisTheoryElements } from '@basis-theory/web-elements';
+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 declare const CardVerificationCodeElement: React.ForwardRefExoticComponent<CardVerificationCodeElementProps & React.RefAttributes<ICardVerificationCodeElement>>;
+export type { CardVerificationCodeElementProps };

package/dist/types/react-elements/src/elements/TextElement.d.ts

@@ -0,0 +1,35 @@
+import React, { MutableRefObject } from 'react';
+import type { TextElement as ITextElement, CreateTextElementOptions, ElementEventListener, ElementStyle, TextElementEvents, InputMode } from '@basis-theory/basis-theory-js/types/elements';
+import type { BasisTheoryElements } from '@basis-theory/web-elements';
+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?];
+    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;
+}
+type TextElementProps = MaskedTextElementProps | PasswordTextElementProps;
+export declare const TextElement: React.ForwardRefExoticComponent<TextElementProps & React.RefAttributes<ITextElement>>;
+export type { TextElementProps };

package/dist/types/react-elements/src/elements/index.d.ts

@@ -0,0 +1,10 @@
+export { CardElement } from './CardElement';
+export type { CardElementProps } from './CardElement';
+export { TextElement } from './TextElement';
+export type { TextElementProps } from './TextElement';
+export { CardNumberElement } from './CardNumberElement';
+export type { CardNumberElementProps } from './CardNumberElement';
+export { CardExpirationDateElement } from './CardExpirationDateElement';
+export type { CardExpirationDateElementProps } from './CardExpirationDateElement';
+export { CardVerificationCodeElement } from './CardVerificationCodeElement';
+export type { CardVerificationCodeElementProps } from './CardVerificationCodeElement';

package/dist/types/react-elements/src/elements/useBasisTheoryValue.d.ts

@@ -0,0 +1,10 @@
+import type { BasisTheoryElements } from '@basis-theory/web-elements';
+/**
+ * Resolves which BasisTheoryReact instance to use,
+ * by favoring the optional parameter.
+ * For internal use only.
+ * @param bt
+ * @returns parameter if it exists; instance from Context otherwise
+ */
+declare const useBasisTheoryValue: (bt?: BasisTheoryElements) => BasisTheoryElements | undefined;
+export { useBasisTheoryValue };

package/dist/types/react-elements/src/elements/useElement.d.ts

@@ -0,0 +1,16 @@
+import React, { ForwardedRef, MutableRefObject } from 'react';
+import type { BaseElement, ElementType } from '@basis-theory/basis-theory-js/types/elements';
+import type { BasisTheoryElements } from '@basis-theory/web-elements';
+/**
+ * Creates, mounts and indexes an Element
+ * with React lifecycle
+ * @param id
+ * @param type
+ * @param options
+ * @param wrapperRef
+ * @param btFromProps
+ * @param ref optional ref to set the underlying element
+ * @returns created element and initial options used for mounting
+ */
+declare const useElement: <Element extends BaseElement<any, any>, Options extends unknown>(id: string, type: ElementType, wrapperRef: React.RefObject<HTMLDivElement>, options: Options, btFromProps?: BasisTheoryElements, ref?: ForwardedRef<Element>, targetValueRef?: MutableRefObject<Element | null>) => Element | undefined;
+export { useElement };

package/dist/types/react-elements/src/elements/useListener.d.ts

@@ -0,0 +1,3 @@
+import type { BaseElement, ElementEventListener, EventType } from '@basis-theory/basis-theory-js/types/elements';
+declare const useListener: <T extends EventType, Ev, E extends BaseElement<unknown, Ev>>(eventType: T, element?: E, listener?: ElementEventListener<Ev, T>) => void;
+export { useListener };

package/dist/types/react-elements/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core';
+export * from './elements';

package/dist/types/react-elements/src/types.d.ts

@@ -0,0 +1 @@
+export * from '@basis-theory/basis-theory-js/types/elements';

package/dist/types/web-elements/src/BasisTheory.d.ts

@@ -0,0 +1,8 @@
+import { BasisTheoryElements } from './types/elements';
+interface BasisTheoryInitOptions {
+    _devMode?: boolean;
+    disableTelemetry?: boolean;
+    useSameOriginApi?: boolean;
+}
+declare const basistheory: (apiKey: string, options?: BasisTheoryInitOptions) => Promise<BasisTheoryElements | undefined>;
+export { basistheory, BasisTheoryInitOptions };

package/dist/types/web-elements/src/common/logging.d.ts

@@ -0,0 +1,8 @@
+export declare const logger: {
+    setTelemetryEnabled: (enabled: boolean) => void;
+    log: {
+        error: (message: string, attributes?: {}) => Promise<void>;
+        info: (message: string, attributes?: {}) => Promise<void>;
+        warn: (message: string, attributes?: {}) => Promise<void>;
+    };
+};

package/dist/types/web-elements/src/elements/constants.d.ts

@@ -0,0 +1,9 @@
+declare const ELEMENTS_INIT_ERROR_MESSAGE = "BasisTheory Elements was not properly initialized.";
+declare const ELEMENTS_NON_DOM_ERROR_MESSAGE = "Tried to load BasisTheoryElements in a non-DOM environment.";
+declare const ELEMENTS_SCRIPT_LOAD_ERROR_MESSAGE = "Basis Theory Elements did not load properly. Check network tab for more details.";
+declare const ELEMENTS_SCRIPT_UNKNOWN_ERROR_MESSAGE = "Unable to load the Elements script. This may be due to network restrictions or browser extensions like ad blockers interfering with script loading. Check browser settings or network connection and try again.";
+declare const ELEMENTS_SCRIPT_FAILED_TO_DELIVER = "Failed to deliver Elements script from Basis Theory. Check your network connection and try again or contact support@basistheory.com";
+declare 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 { AUTOCOMPLETE_VALUES, CARD_BRANDS, CARD_ICON_POSITIONS, ELEMENTS_INIT_ERROR_MESSAGE, ELEMENTS_NON_DOM_ERROR_MESSAGE, ELEMENTS_SCRIPT_FAILED_TO_DELIVER, ELEMENTS_SCRIPT_LOAD_ERROR_MESSAGE, ELEMENTS_SCRIPT_UNKNOWN_ERROR_MESSAGE, };

package/dist/types/web-elements/src/elements/getOrCreateScriptElement.d.ts

@@ -0,0 +1 @@
+export declare const getOrCreateScriptElement: (url: string) => HTMLScriptElement;

package/dist/types/web-elements/src/elements/index.d.ts

@@ -0,0 +1,2 @@
+export * from './getOrCreateScriptElement';
+export * from './loadElements';

package/dist/types/web-elements/src/elements/loadElements.d.ts

@@ -0,0 +1,3 @@
+import type { BasisTheoryElementsInternal } from '../types/elements';
+declare const loadElements: (elementsClientUrl?: string) => Promise<BasisTheoryElementsInternal>;
+export { loadElements };

package/dist/types/web-elements/src/index.d.ts

@@ -0,0 +1,8 @@
+import { basistheory } from './BasisTheory';
+declare global {
+    interface Window {
+        basistheory?: typeof basistheory;
+    }
+}
+export * from './BasisTheory';
+export * from './types';

package/dist/types/web-elements/src/types/elements/cardTypes.d.ts

@@ -0,0 +1,29 @@
+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';
+type CreditCardType = {
+    code: {
+        size: number;
+        name: SecurityCodeLabel | string;
+    };
+    gaps: number[];
+    lengths: number[];
+    niceType: CardBrandNiceType | string;
+    patterns: (number | [number, number])[];
+    type: CardBrandId | string;
+};
+declare const VISA: CreditCardType;
+declare const MASTERCARD: CreditCardType;
+declare const AMERICAN_EXPRESS: CreditCardType;
+declare const DINERS_CLUB: CreditCardType;
+declare const DISCOVER: CreditCardType;
+declare const JCB: CreditCardType;
+declare const UNION_PAY: CreditCardType;
+declare const MAESTRO: CreditCardType;
+declare const ELO: CreditCardType;
+declare const MIR: CreditCardType;
+declare const HIPER: CreditCardType;
+declare const HIPERCARD: CreditCardType;
+declare const DEFAULT_CARD_TYPES: CreditCardType[];
+export { AMERICAN_EXPRESS, DEFAULT_CARD_TYPES, DINERS_CLUB, DISCOVER, ELO, HIPER, HIPERCARD, JCB, MAESTRO, MASTERCARD, MIR, UNION_PAY, VISA, };
+export type { CreditCardType };

package/dist/types/web-elements/src/types/elements/elements.d.ts

@@ -0,0 +1,74 @@
+import type { HttpClient } from '../../types/sdk';
+import type { CardElementEvents, CardExpirationDateElementEvents, CardNumberElementEvents, CardVerificationCodeElementEvents, ElementEventListener, EventType, Subscription, TextElementEvents } from './events';
+import type { CardElementValue, CardExpirationDateValue, CreateCardElementOptions, CreateCardExpirationDateElementOptions, CreateCardNumberElementOptions, CreateCardVerificationCodeElementOptions, CreateTextElementOptions, UpdateCardElementOptions, UpdateCardExpirationDateElementOptions, UpdateCardNumberElementOptions, UpdateCardVerificationCodeElementOptions, UpdateTextElementOptions } from './options';
+import type { Proxy, Tokenize, Tokens, TokenIntents } from './services';
+import type { CardMetadata, DataElementReference, ElementMetadata } from './shared';
+import { Sessions } from './services/sessions';
+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;
+}
+type CardElement = BaseElement<UpdateCardElementOptions, CardElementEvents> & {
+    readonly cardMetadata?: CardMetadata;
+    setValue(value: CardElementValue<'reference'>): void;
+    validate(): void;
+};
+type TextElement = BaseElement<UpdateTextElementOptions, TextElementEvents> & {
+    setValueRef(value: TextElement): void;
+    setValue(value: DataElementReference): void;
+};
+type CardNumberElement = BaseElement<UpdateCardNumberElementOptions, CardNumberElementEvents> & {
+    readonly cardMetadata?: CardMetadata;
+    setValueRef(value: CardNumberElement): void;
+    setValue(value: DataElementReference): void;
+};
+type CardExpirationDateElement = BaseElement<UpdateCardExpirationDateElementOptions, CardExpirationDateElementEvents> & {
+    setValueRef(value: CardExpirationDateElement): void;
+    setValue(value: CardExpirationDateValue<'reference'>): void;
+    month(): ElementWrapper<CardExpirationDateElement>;
+    year(): ElementWrapper<CardExpirationDateElement>;
+    format(dateFormat: string): ElementWrapper<CardExpirationDateElement>;
+};
+type CardVerificationCodeElement = BaseElement<UpdateCardVerificationCodeElementOptions, CardVerificationCodeElementEvents> & {
+    setValueRef(value: CardVerificationCodeElement): void;
+    setValue(value: DataElementReference): void;
+};
+type ElementWrapper<T extends BaseElement<any, any> = BaseElement<any, any>> = {
+    element: T;
+    method?: string;
+    formattingOptions?: {
+        format: string;
+    };
+};
+type ElementValue = TextElement | CardElement | CardNumberElement | CardExpirationDateElement | CardVerificationCodeElement | ElementWrapper;
+interface BasisTheoryElements {
+    tokens: Tokens;
+    proxy: Proxy;
+    sessions: Sessions;
+    tokenIntents: TokenIntents;
+    tokenize: Tokenize;
+    client: HttpClient;
+    createElement(type: 'card', options?: CreateCardElementOptions): CardElement;
+    createElement(type: 'text', options: CreateTextElementOptions): TextElement;
+    createElement(type: 'cardNumber', options: CreateCardNumberElementOptions): CardNumberElement;
+    createElement(type: 'cardExpirationDate', options: CreateCardExpirationDateElementOptions): CardExpirationDateElement;
+    createElement(type: 'cardVerificationCode', options: CreateCardVerificationCodeElementOptions): CardVerificationCodeElement;
+}
+interface BasisTheoryElementsInternal extends BasisTheoryElements {
+    init: (apiKey: string | undefined, elementsBaseUrl: string, elementsUseNgApi: boolean | undefined, disableTelemetry: boolean | undefined, elementsUseSameOriginApi: boolean | undefined) => Promise<BasisTheoryElements>;
+    hasElement: (payload: unknown) => boolean;
+}
+declare global {
+    interface Window {
+        BasisTheoryElements?: BasisTheoryElementsInternal;
+    }
+}
+export type { BaseElement, CardElement, TextElement, CardNumberElement, CardExpirationDateElement, CardVerificationCodeElement, ElementWrapper, ElementValue, BasisTheoryElements, BasisTheoryElementsInternal, };

package/dist/types/web-elements/src/types/elements/events.d.ts

@@ -0,0 +1,40 @@
+import type { Brand, FieldError, ListenableKey, Targeted } from './shared';
+type EventType = 'ready' | 'change' | 'focus' | 'blur' | 'keydown';
+interface BaseEvent<T extends EventType> {
+    type: T;
+}
+type ReadyEvent = BaseEvent<'ready'>;
+type ChangeEvent = BaseEvent<'change'> & {
+    empty: boolean;
+    complete: boolean;
+    valid?: boolean;
+    maskSatisfied?: boolean;
+    errors?: FieldError[];
+};
+type CardChangeEvent = ChangeEvent & {
+    cardBrand: Brand;
+    cardLast4?: string;
+    cardBin?: string;
+};
+type InputFocusEvent = BaseEvent<'focus'> & Targeted;
+type InputBlurEvent = BaseEvent<'blur'> & Targeted;
+type InputKeydownEvent = BaseEvent<'keydown'> & Targeted & {
+    key: ListenableKey;
+} & Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'shiftKey' | 'metaKey'>;
+type BaseElementEvents = ReadyEvent | InputFocusEvent | InputBlurEvent | InputKeydownEvent;
+type TextElementEvents = BaseElementEvents | ChangeEvent;
+type CardElementEvents = BaseElementEvents | CardChangeEvent;
+type CardNumberElementEvents = BaseElementEvents | CardChangeEvent;
+type CardExpirationDateElementEvents = BaseElementEvents | ChangeEvent;
+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;
+type ElementEventListener<Events, Type> = (event: FindByType<Events, Type>) => void;
+interface Subscription {
+    unsubscribe(): void;
+}
+export type { EventType, BaseEvent, ReadyEvent, ChangeEvent, CardChangeEvent, InputFocusEvent, InputBlurEvent, InputKeydownEvent, BaseElementEvents, TextElementEvents, CardElementEvents, CardNumberElementEvents, CardExpirationDateElementEvents, CardVerificationCodeElementEvents, ElementEventListener, Subscription, };

package/dist/types/web-elements/src/types/elements/index.d.ts

@@ -0,0 +1,7 @@
+export * from './cardTypes';
+export * from './elements';
+export * from './events';
+export * from './options';
+export * from './services';
+export * from './shared';
+export * from './styles';

package/dist/types/web-elements/src/types/elements/options.d.ts

@@ -0,0 +1,98 @@
+import { CreditCardType } from './cardTypes';
+import { AutoCompleteValue, DataElementReference } from './shared';
+import type { CopyIconStyles, ElementStyle } from './styles';
+declare const ELEMENTS_TYPES: readonly ["card", "cardExpirationDate", "cardNumber", "cardVerificationCode", "data", "text"];
+type ElementType = typeof ELEMENTS_TYPES[number];
+interface ElementInternalOptions {
+    apiKey: string | undefined;
+    baseUrl: string;
+    type: ElementType;
+    useNgApi: boolean | undefined;
+    useSameOriginApi: boolean | undefined;
+}
+declare enum InputMode {
+    DECIMAL = "decimal",
+    EMAIL = "email",
+    NONE = "none",
+    NUMERIC = "numeric",
+    SEARCH = "search",
+    TEL = "tel",
+    TEXT = "text",
+    URL = "url"
+}
+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;
+}
+type ElementOptions = ElementInternalOptions & SanitizedElementOptions;
+type Transform = RegExp | [RegExp, string?] | null;
+interface TransformOption {
+    transform?: Transform;
+}
+interface AutoCompleteOption {
+    autoComplete?: AutoCompleteValue;
+}
+type CustomizableElementOptions = Pick<ElementOptions, 'cardTypes' | 'copyIconStyles' | 'disabled' | 'enableCopy' | 'inputMode' | 'readOnly' | 'skipLuhnValidation' | 'style' | 'validateOnChange'> & AutoCompleteOption;
+type ElementValueType = 'static' | 'reference';
+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;
+}
+interface CardElementPlaceholder {
+    cardNumber?: string;
+    cardExpirationDate?: string;
+    cardSecurityCode?: string;
+}
+interface CardExpirationDateValue<T extends ElementValueType> {
+    month: T extends 'reference' ? DataElementReference : number;
+    year: T extends 'reference' ? DataElementReference : number;
+}
+type CreateCardElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'cardTypes' | 'skipLuhnValidation'> & {
+    placeholder?: CardElementPlaceholder;
+    value?: CardElementValue<'static'>;
+};
+type UpdateCardElementOptions = Omit<CreateCardElementOptions, 'validateOnChange' | 'enableCopy'>;
+type CreateTextElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder' | 'mask' | 'maxLength' | 'password' | 'validation'> & TransformOption & Required<Pick<ElementOptions, 'targetId'>> & {
+    'aria-label'?: string;
+    value?: string;
+};
+type UpdateTextElementOptions = Omit<CreateTextElementOptions, 'targetId' | 'mask' | 'validateOnChange'>;
+type CreateCardNumberElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder' | 'iconPosition' | 'cardTypes' | 'skipLuhnValidation'> & Required<Pick<ElementOptions, 'targetId'>> & {
+    'aria-label'?: string;
+    value?: string;
+};
+type UpdateCardNumberElementOptions = Omit<CreateCardNumberElementOptions, 'targetId' | 'validateOnChange' | 'enableCopy'>;
+type CreateCardExpirationDateElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder'> & Required<Pick<ElementOptions, 'targetId'>> & {
+    'aria-label'?: string;
+    value?: CardExpirationDateValue<'static'> | string;
+};
+type UpdateCardExpirationDateElementOptions = Omit<CreateCardExpirationDateElementOptions, 'targetId' | 'validateOnChange' | 'enableCopy'>;
+type CreateCardVerificationCodeElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder' | 'cardBrand'> & Required<Pick<ElementOptions, 'targetId'>> & {
+    'aria-label'?: string;
+    value?: string;
+};
+type UpdateCardVerificationCodeElementOptions = Omit<CreateCardVerificationCodeElementOptions, 'targetId' | 'validateOnChange' | 'enableCopy'>;
+export type { CardElementPlaceholder, CardElementValue, CardExpirationDateValue, CreateCardElementOptions, CreateCardExpirationDateElementOptions, CreateCardNumberElementOptions, CreateCardVerificationCodeElementOptions, CreateTextElementOptions, CustomizableElementOptions, ElementInternalOptions, ElementOptions, ElementType, InputMode, SanitizedElementOptions, Transform, UpdateCardElementOptions, UpdateCardExpirationDateElementOptions, UpdateCardNumberElementOptions, UpdateCardVerificationCodeElementOptions, UpdateTextElementOptions, };
+export { ELEMENTS_TYPES };

package/dist/types/web-elements/src/types/elements/services/index.d.ts

@@ -0,0 +1,4 @@
+export * from './tokenize';
+export * from './tokens';
+export * from './proxy';
+export * from './token-intents';

package/dist/types/web-elements/src/types/elements/services/proxy.d.ts

@@ -0,0 +1,27 @@
+import { RequestOptions } from './shared';
+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>;
+interface ProxyRequestOptions extends RequestOptions {
+    includeResponseHeaders?: boolean;
+    path?: string;
+    query?: ProxyQuery;
+    headers?: ProxyHeaders;
+    body?: unknown;
+}
+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 { Proxy, ProxyRequestOptions };

package/dist/types/web-elements/src/types/elements/services/sessions.d.ts

@@ -0,0 +1,11 @@
+import { RequestOptions } from './shared';
+type CreateSessionResponse = {
+    sessionKey: string;
+    nonce: string;
+    expiresAt: string;
+    _debug?: Record<string, unknown>;
+};
+interface Sessions {
+    create(options?: RequestOptions): Promise<CreateSessionResponse>;
+}
+export { CreateSessionResponse, Sessions };

package/dist/types/web-elements/src/types/elements/services/shared.d.ts

@@ -0,0 +1,21 @@
+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>;
+};
+type Patch<P> = {
+    patch(id: string, model: P, options?: RequestOptions): Promise<void>;
+};
+type Delete = {
+    delete(id: string, options?: RequestOptions): Promise<void>;
+};
+export { RequestOptions, Create, Retrieve, Update, Delete, Patch };

package/dist/types/web-elements/src/types/elements/services/token-intents.d.ts

@@ -0,0 +1,6 @@
+import type { ElementValue } from '../../elements';
+import type { CreateTokenIntent as CreateTokenIntentModel, TokenIntent } from '../../models';
+import { Create } from './shared';
+type CreateTokenIntent = CreateTokenIntentModel<ElementValue>;
+type TokenIntents = Create<TokenIntent, CreateTokenIntent>;
+export type { TokenIntents, CreateTokenIntent };

package/dist/types/web-elements/src/types/elements/services/tokenize.d.ts

@@ -0,0 +1,8 @@
+import type { ElementValue } from '../';
+import type { TokenizeData as TokenizeDataModel } from '../../models';
+import { RequestOptions } from './shared';
+type TokenizeData = TokenizeDataModel<ElementValue>;
+interface Tokenize {
+    tokenize(tokens: TokenizeData, options?: RequestOptions): Promise<TokenizeDataModel>;
+}
+export type { Tokenize, TokenizeData };

package/dist/types/web-elements/src/types/elements/services/tokens.d.ts

@@ -0,0 +1,7 @@
+import type { ElementValue } from '../../elements';
+import type { CreateToken as CreateTokenModel, UpdateToken as UpdateTokenModel, Token } from '../../models';
+import { Create, Retrieve, Update } from './shared';
+type CreateToken = CreateTokenModel<ElementValue>;
+type UpdateToken = UpdateTokenModel<ElementValue>;
+type Tokens = Create<Token, CreateToken> & Retrieve<Token<unknown>> & Update<Token, UpdateToken>;
+export type { Tokens, CreateToken, UpdateToken };

package/dist/types/web-elements/src/types/elements/shared.d.ts

@@ -0,0 +1,51 @@
+import { AUTOCOMPLETE_VALUES, CARD_BRANDS, CARD_ICON_POSITIONS } from '../../elements/constants';
+type FieldErrorType = 'incomplete' | 'invalid';
+type ConfigErrorType = 'missing-configuration' | 'missing-permission' | 'invalid-configuration';
+interface ConfigError {
+    type: ConfigErrorType;
+    message: string;
+}
+interface Targeted {
+    targetId: string;
+}
+type ListenableKey = 'Escape' | 'Enter';
+interface FieldError {
+    targetId: string;
+    type: FieldErrorType;
+}
+interface PropertyError {
+    type: FieldErrorType;
+}
+interface ElementMetadata {
+    complete: boolean;
+    valid: boolean;
+    maskSatisfied?: boolean;
+    empty: boolean;
+    errors?: FieldError[] | Omit<FieldError, 'targetId'>[];
+}
+interface CardMetadata {
+    cardBrand: Brand;
+    cardLast4?: string;
+    cardBin?: string;
+}
+/**
+ * Card brands type
+ */
+type Brand = typeof CARD_BRANDS[number];
+/**
+ * Icon position for card number element
+ */
+type CardIconPosition = typeof CARD_ICON_POSITIONS[number];
+/**
+ * Values for the element input autocomplete attribute
+ */
+type AutoCompleteValue = typeof AUTOCOMPLETE_VALUES[number];
+/**
+ * Type used for detokenization responses stored on Data Elements
+ */
+type DataElementReference = {
+    correlationId: string;
+    elementId: string;
+    path: string;
+};
+export type { AutoCompleteValue, Brand, CardIconPosition, CardMetadata, ConfigError, ConfigErrorType, DataElementReference, ElementMetadata, FieldError, FieldErrorType, ListenableKey, PropertyError, Targeted, };