@basis-theory/react-elements 1.5.0 → 1.7.2

package/dist/types/index.d.ts

@@ -0,0 +1,617 @@
+import { Properties } from "csstype";
+import React, { PropsWithChildren, MutableRefObject } from "react";
+import { CardElement as _CardElement2, CardElementEvents as _CardElementEvents1, CardElementPlaceholder as _CardElementPlaceholder1, CardElementValue as _CardElementValue1, CopyIconStyles as _CopyIconStyles1, CreateCardElementOptions as _CreateCardElementOptions1, CreditCardType as _CreditCardType1, ElementEventListener as _ElementEventListener1, ElementStyle as _ElementStyle1, InputMode as _InputMode1, TextElement as _TextElement2, CreateTextElementOptions as _CreateTextElementOptions1, TextElementEvents as _TextElementEvents1, CardNumberElement as _CardNumberElement2, CreateCardNumberElementOptions as _CreateCardNumberElementOptions1, CardNumberElementEvents as _CardNumberElementEvents1, SanitizedElementOptions as _SanitizedElementOptions1, CardExpirationDateElement as _CardExpirationDateElement2, CreateCardExpirationDateElementOptions as _CreateCardExpirationDateElementOptions1, CardExpirationDateElementEvents as _CardExpirationDateElementEvents1, CardExpirationDateValue as _CardExpirationDateValue1, CardVerificationCodeElement as _CardVerificationCodeElement2, CreateCardVerificationCodeElementOptions as _CreateCardVerificationCodeElementOptions1, CardVerificationCodeElementEvents as _CardVerificationCodeElementEvents1, Brand as _Brand1 } from "@basis-theory/basis-theory-js/types/elements";
+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;
+};
+interface RequestConfig {
+    headers?: Record<string, string>;
+}
+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>;
+}
+declare const CARD_BRANDS: readonly ["visa", "mastercard", "american-express", "discover", "diners-club", "jcb", "unionpay", "maestro", "elo", "hiper", "hipercard", "mir", "unknown"];
+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"];
+type FieldErrorType = 'incomplete' | 'invalid';
+interface Targeted {
+    targetId: string;
+}
+type ListenableKey = 'Escape' | 'Enter';
+interface FieldError {
+    targetId: string;
+    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];
+/**
+ * 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;
+};
+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;
+}
+declare const SAFE_CSS_PROPERTIES: readonly ["backgroundColor", "color", "fontFamily", "fontSize", "fontSmooth", "fontStyle", "fontVariant", "fontWeight", "lineHeight", "letterSpacing", "textAlign", "padding", "textDecoration", "textShadow", "textTransform"];
+type SafeCSSProperty = typeof SAFE_CSS_PROPERTIES[number];
+type SafeStyle = Pick<Properties, SafeCSSProperty>;
+declare const CARD_ELEMENT_STYLE_VARIANT_SELECTORS: readonly [":hover", ":focus", ":read-only", "::placeholder", "::selection", ":disabled"];
+type CardElementStyleVariantSelector = typeof CARD_ELEMENT_STYLE_VARIANT_SELECTORS[number];
+type CardElementStyleVariantStyle = SafeStyle & Partial<Record<CardElementStyleVariantSelector, SafeStyle>>;
+declare const CARD_ELEMENT_STYLE_VARIANTS: readonly ["base", "complete", "invalid", "empty"];
+declare const CARD_ELEMENT_STYLE_FONTS_ATTR: "fonts";
+type CardElementStyleVariant = typeof CARD_ELEMENT_STYLE_VARIANTS[number];
+type CardElementStyleFontAttr = typeof CARD_ELEMENT_STYLE_FONTS_ATTR;
+type FontSource = string;
+type FontSources = FontSource[];
+type Fonts = Record<CardElementStyleFontAttr, FontSources>;
+type CardElementStyle = Partial<Record<CardElementStyleVariant, CardElementStyleVariantStyle> & Fonts>;
+type ElementStyle = CardElementStyle;
+type CopyIconStyles = {
+    size?: string;
+    color?: string;
+    successColor?: string;
+};
+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;
+}
+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'>;
+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;
+}
+interface BinDetailsBank {
+    name?: string;
+    phone?: string;
+    url?: string;
+    cleanName?: string;
+}
+interface BinDetailsCountry {
+    alpha2?: string;
+    name?: string;
+    numeric?: string;
+}
+interface BinDetailsProduct {
+    code?: string;
+    name?: string;
+}
+type Primitive = string | number | boolean | null;
+type TokenType = 'token' | 'card' | 'bank' | 'card_number' | 'us_bank_routing_number' | 'us_bank_account_number' | 'social_security_number';
+interface Auditable {
+    createdBy?: string;
+    createdAt?: string;
+    modifiedBy?: string;
+    modifiedAt?: string;
+}
+type DataObject<DataType = Primitive> = {
+    [member: string]: TokenData<DataType>;
+};
+type DataArray<DataType> = Array<TokenData<DataType>>;
+type TokenData<DataType = Primitive> = Primitive | DataObject<DataType> | DataArray<DataType> | DataType;
+interface TokenBase<DataType = Primitive> extends Auditable {
+    data: TokenData<DataType>;
+    type: TokenType;
+}
+declare const DATA_CLASSIFICATIONS: readonly ["general", "bank", "pci", "pii"];
+type DataClassification = typeof DATA_CLASSIFICATIONS[number];
+declare const DATA_IMPACT_LEVELS: readonly ["low", "moderate", "high"];
+type DataImpactLevel = typeof DATA_IMPACT_LEVELS[number];
+declare const DATA_RESTRICTION_POLICIES: readonly ["mask", "redact"];
+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;
+}
+interface TokenEnrichments {
+    binDetails?: BinDetails;
+}
+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>;
+};
+type CreateToken<DataType = Primitive> = Pick<Token<DataType>, 'type' | 'data' | 'privacy' | 'containers' | 'metadata' | 'encryption' | 'searchIndexes' | 'fingerprintExpression' | 'mask' | 'expiresAt'> & {
+    deduplicateToken?: boolean;
+    id?: string;
+};
+type UpdateToken<DataType = Primitive> = Partial<Pick<Token<DataType>, 'data' | 'containers' | 'metadata' | 'encryption' | 'searchIndexes' | 'fingerprintExpression' | 'mask' | 'expiresAt'> & {
+    privacy: Omit<TokenPrivacy, 'classification'>;
+    deduplicateToken: boolean;
+}>;
+type TokenizeObject<DataType = Primitive> = {
+    [key: string]: Primitive | TokenizeObject<DataType> | TokenizeArray<DataType> | DataType;
+};
+type TokenizeArray<DataType = Primitive> = Array<Primitive | TokenizeObject<DataType> | TokenizeArray<DataType> | DataType>;
+type TokenizeData<DataType = Primitive> = TokenizeArray<DataType> | TokenizeObject<DataType>;
+interface TokenIntentCardDetails {
+    type: 'card';
+    card: {
+        bin: string;
+        last4: string;
+        brand: string;
+        funding: string;
+        expirationMonth: number;
+        expirationYear: number;
+    };
+}
+type TokenTypesForTokenIntents = Exclude<TokenType, 'token' | 'card'>;
+type TokenTypeMap = {
+    [K in TokenTypesForTokenIntents]: {
+        type: K;
+    } & Record<K, Record<string, unknown>>;
+};
+type TokenIntent<DataType = DataObject> = (TokenBase<DataType> & Omit<Auditable, 'modifiedAt' | 'modifiedBy'> & {
+    id: string;
+    tenantId: string;
+    expiresAt: string;
+    fingerprint?: string;
+}) & (TokenTypeMap[TokenTypesForTokenIntents] | TokenIntentCardDetails | {
+    type: 'token';
+});
+type CreateTokenIntent<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>;
+};
+type _TokenizeData1 = TokenizeData<ElementValue>;
+interface Tokenize {
+    tokenize(tokens: _TokenizeData1, options?: RequestOptions): Promise<TokenizeData>;
+}
+type _CreateToken1 = CreateToken<ElementValue>;
+type _UpdateToken1 = UpdateToken<ElementValue>;
+type Tokens = Create<Token, _CreateToken1> & Retrieve<Token<unknown>> & Update<Token, _UpdateToken1>;
+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>;
+}
+type _CreateTokenIntent1 = CreateTokenIntent<ElementValue>;
+type TokenIntents = Create<TokenIntent, _CreateTokenIntent1>;
+type CreateSessionResponse = {
+    sessionKey: string;
+    nonce: string;
+    expiresAt: string;
+    _debug?: Record<string, unknown>;
+};
+interface Sessions {
+    create(options?: RequestOptions): Promise<CreateSessionResponse>;
+}
+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 _CardElement1 = BaseElement<UpdateCardElementOptions, CardElementEvents> & {
+    readonly cardMetadata?: CardMetadata;
+    setValue(value: CardElementValue<'reference'>): void;
+    validate(): void;
+};
+type _TextElement1 = BaseElement<UpdateTextElementOptions, TextElementEvents> & {
+    setValueRef(value: _TextElement1): void;
+    setValue(value: DataElementReference): void;
+};
+type _CardNumberElement1 = BaseElement<UpdateCardNumberElementOptions, CardNumberElementEvents> & {
+    readonly cardMetadata?: CardMetadata;
+    setValueRef(value: _CardNumberElement1): void;
+    setValue(value: DataElementReference): void;
+};
+type _CardExpirationDateElement1 = BaseElement<UpdateCardExpirationDateElementOptions, CardExpirationDateElementEvents> & {
+    setValueRef(value: _CardExpirationDateElement1): void;
+    setValue(value: CardExpirationDateValue<'reference'>): void;
+    month(): ElementWrapper<_CardExpirationDateElement1>;
+    year(): ElementWrapper<_CardExpirationDateElement1>;
+    format(dateFormat: string): ElementWrapper<_CardExpirationDateElement1>;
+};
+type _CardVerificationCodeElement1 = BaseElement<UpdateCardVerificationCodeElementOptions, CardVerificationCodeElementEvents> & {
+    setValueRef(value: _CardVerificationCodeElement1): void;
+    setValue(value: DataElementReference): void;
+};
+type ElementWrapper<T extends BaseElement<any, any> = BaseElement<any, any>> = {
+    element: T;
+    method?: string;
+    formattingOptions?: {
+        format: string;
+    };
+};
+type ElementValue = _TextElement1 | _CardElement1 | _CardNumberElement1 | _CardExpirationDateElement1 | _CardVerificationCodeElement1 | ElementWrapper;
+interface BasisTheoryElements {
+    tokens: Tokens;
+    proxy: Proxy;
+    sessions: Sessions;
+    tokenIntents: TokenIntents;
+    tokenize: Tokenize;
+    client: HttpClient;
+    createElement(type: 'card', options?: CreateCardElementOptions): _CardElement1;
+    createElement(type: 'text', options: CreateTextElementOptions): _TextElement1;
+    createElement(type: 'cardNumber', options: CreateCardNumberElementOptions): _CardNumberElement1;
+    createElement(type: 'cardExpirationDate', options: CreateCardExpirationDateElementOptions): _CardExpirationDateElement1;
+    createElement(type: 'cardVerificationCode', options: CreateCardVerificationCodeElementOptions): _CardVerificationCodeElement1;
+}
+declare global {
+    interface Window {
+        BasisTheoryElements?: BasisTheoryElementsInternal;
+    }
+}
+interface BasisTheoryInitOptions {
+    _devMode?: boolean;
+    disableTelemetry?: boolean;
+    useSameOriginApi?: boolean;
+}
+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 | undefined, options?: BasisTheoryInitOptions | undefined) => {
+    bt: BasisTheoryElements | undefined;
+    error: Error | undefined;
+} | {
+    bt: BasisTheoryElements | undefined;
+    error?: undefined;
+};
+export { BasisTheoryApiError, BasisTheoryValidationError, } from '@basis-theory/basis-theory-js/common';
+export { AMERICAN_EXPRESS, DEFAULT_CARD_TYPES, DINERS_CLUB, DISCOVER, ELO, HIPER, HIPERCARD, JCB, MAESTRO, MASTERCARD, MIR, UNION_PAY, VISA, } from '@basis-theory/basis-theory-js/types/elements';
+export interface CardElementProps {
+    autoComplete?: _CreateCardElementOptions1['autoComplete'];
+    bt?: BasisTheoryElements;
+    cardTypes?: _CreditCardType1[];
+    copyIconStyles?: _CopyIconStyles1;
+    disabled?: boolean;
+    enableCopy?: boolean;
+    id: string;
+    inputMode?: `${_InputMode1}`;
+    onBlur?: _ElementEventListener1<_CardElementEvents1, 'blur'>;
+    onChange?: _ElementEventListener1<_CardElementEvents1, 'change'>;
+    onFocus?: _ElementEventListener1<_CardElementEvents1, 'focus'>;
+    onKeyDown?: _ElementEventListener1<_CardElementEvents1, 'keydown'>;
+    onReady?: _ElementEventListener1<_CardElementEvents1, 'ready'>;
+    placeholder?: _CardElementPlaceholder1;
+    readOnly?: boolean;
+    skipLuhnValidation?: boolean;
+    style?: _ElementStyle1;
+    validateOnChange?: boolean;
+    value?: _CardElementValue1<'static'>;
+}
+export const CardElement: React.ForwardRefExoticComponent<CardElementProps & React.RefAttributes<_CardElement2>>;
+interface BaseTextElementProps {
+    'aria-label'?: string;
+    autoComplete?: _CreateTextElementOptions1['autoComplete'];
+    bt?: BasisTheoryElements;
+    disabled?: boolean;
+    id: string;
+    inputMode?: `${_InputMode1}`;
+    maxLength?: HTMLInputElement['maxLength'];
+    onBlur?: _ElementEventListener1<_TextElementEvents1, 'blur'>;
+    onChange?: _ElementEventListener1<_TextElementEvents1, 'change'>;
+    onFocus?: _ElementEventListener1<_TextElementEvents1, 'focus'>;
+    onKeyDown?: _ElementEventListener1<_TextElementEvents1, 'keydown'>;
+    onReady?: _ElementEventListener1<_TextElementEvents1, 'ready'>;
+    placeholder?: string;
+    readOnly?: boolean;
+    style?: _ElementStyle1;
+    transform?: RegExp | [RegExp, string?];
+    validation?: RegExp;
+    value?: string;
+    valueRef?: MutableRefObject<_TextElement2 | 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<_TextElement2>>;
+export interface CardNumberElementProps {
+    'aria-label'?: string;
+    autoComplete?: _CreateCardNumberElementOptions1['autoComplete'];
+    bt?: BasisTheoryElements;
+    cardTypes?: _CreditCardType1[];
+    copyIconStyles?: _CopyIconStyles1;
+    disabled?: boolean;
+    enableCopy?: boolean;
+    iconPosition?: _SanitizedElementOptions1['iconPosition'];
+    id: string;
+    inputMode?: `${_InputMode1}`;
+    onBlur?: _ElementEventListener1<_CardNumberElementEvents1, 'blur'>;
+    onChange?: _ElementEventListener1<_CardNumberElementEvents1, 'change'>;
+    onFocus?: _ElementEventListener1<_CardNumberElementEvents1, 'focus'>;
+    onKeyDown?: _ElementEventListener1<_CardNumberElementEvents1, 'keydown'>;
+    onReady?: _ElementEventListener1<_CardNumberElementEvents1, 'ready'>;
+    placeholder?: string;
+    readOnly?: boolean;
+    skipLuhnValidation?: boolean;
+    style?: _ElementStyle1;
+    validateOnChange?: boolean;
+    value?: string;
+    valueRef?: MutableRefObject<_CardNumberElement2 | null>;
+}
+export const CardNumberElement: React.ForwardRefExoticComponent<CardNumberElementProps & React.RefAttributes<_CardNumberElement2>>;
+export interface CardExpirationDateElementProps {
+    'aria-label'?: string;
+    autoComplete?: _CreateCardExpirationDateElementOptions1['autoComplete'];
+    bt?: BasisTheoryElements;
+    copyIconStyles?: _CopyIconStyles1;
+    disabled?: boolean;
+    enableCopy?: boolean;
+    id: string;
+    inputMode?: `${_InputMode1}`;
+    onBlur?: _ElementEventListener1<_CardExpirationDateElementEvents1, 'blur'>;
+    onChange?: _ElementEventListener1<_CardExpirationDateElementEvents1, 'change'>;
+    onFocus?: _ElementEventListener1<_CardExpirationDateElementEvents1, 'focus'>;
+    onKeyDown?: _ElementEventListener1<_CardExpirationDateElementEvents1, 'keydown'>;
+    onReady?: _ElementEventListener1<_CardExpirationDateElementEvents1, 'ready'>;
+    placeholder?: string;
+    readOnly?: boolean;
+    style?: _ElementStyle1;
+    validateOnChange?: boolean;
+    value?: _CardExpirationDateValue1<'static'> | string;
+    valueRef?: MutableRefObject<_CardExpirationDateElement2 | null>;
+}
+export const CardExpirationDateElement: React.ForwardRefExoticComponent<CardExpirationDateElementProps & React.RefAttributes<_CardExpirationDateElement2>>;
+export interface CardVerificationCodeElementProps {
+    'aria-label'?: string;
+    autoComplete?: _CreateCardVerificationCodeElementOptions1['autoComplete'];
+    bt?: BasisTheoryElements;
+    cardBrand?: _Brand1 | string;
+    copyIconStyles?: _CopyIconStyles1;
+    disabled?: boolean;
+    enableCopy?: boolean;
+    id: string;
+    inputMode?: `${_InputMode1}`;
+    onBlur?: _ElementEventListener1<_CardVerificationCodeElementEvents1, 'blur'>;
+    onChange?: _ElementEventListener1<_CardVerificationCodeElementEvents1, 'change'>;
+    onFocus?: _ElementEventListener1<_CardVerificationCodeElementEvents1, 'focus'>;
+    onKeyDown?: _ElementEventListener1<_CardVerificationCodeElementEvents1, 'keydown'>;
+    onReady?: _ElementEventListener1<_CardVerificationCodeElementEvents1, 'ready'>;
+    placeholder?: string;
+    readOnly?: boolean;
+    style?: _ElementStyle1;
+    validateOnChange?: boolean;
+    value?: string;
+    valueRef?: MutableRefObject<_CardVerificationCodeElement2 | null>;
+}
+export const CardVerificationCodeElement: React.ForwardRefExoticComponent<CardVerificationCodeElementProps & React.RefAttributes<_CardVerificationCodeElement2>>;

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

@@ -0,0 +1,11 @@
+import type { BasisTheoryElements } from '@basis-theory/web-elements';
+import { PropsWithChildren } from 'react';
+interface BasisTheoryProviderValue {
+    bt?: BasisTheoryElements;
+}
+interface BasisTheoryProviderProps {
+    bt?: BasisTheoryElements;
+}
+declare const BasisTheoryProvider: ({ bt, children, }: PropsWithChildren<BasisTheoryProviderProps>) => JSX.Element;
+declare const useBasisTheoryFromContext: () => BasisTheoryProviderValue;
+export { BasisTheoryProvider, useBasisTheoryFromContext };

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

@@ -0,0 +1,4 @@
+export { useBasisTheory } from './useBasisTheory';
+export { BasisTheoryProvider } from './BasisTheoryProvider';
+export { BasisTheoryApiError, BasisTheoryValidationError, } from '@basis-theory/basis-theory-js/common';
+export { AMERICAN_EXPRESS, DEFAULT_CARD_TYPES, DINERS_CLUB, DISCOVER, ELO, HIPER, HIPERCARD, JCB, MAESTRO, MASTERCARD, MIR, UNION_PAY, VISA, } from '@basis-theory/basis-theory-js/types/elements';

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

@@ -0,0 +1,9 @@
+import type { BasisTheoryElements, BasisTheoryInitOptions } from '@basis-theory/web-elements';
+declare const useBasisTheory: (apiKey?: string, options?: BasisTheoryInitOptions) => {
+    bt: BasisTheoryElements | undefined;
+    error: Error | undefined;
+} | {
+    bt: BasisTheoryElements | undefined;
+    error?: undefined;
+};
+export { useBasisTheory };

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

@@ -0,0 +1,26 @@
+import React from 'react';
+import { CardElement as ICardElement, CardElementEvents, CardElementPlaceholder, CardElementValue, CopyIconStyles, CreateCardElementOptions, CreditCardType, ElementEventListener, ElementStyle, InputMode } from '@basis-theory/basis-theory-js/types/elements';
+import type { BasisTheoryElements } from '@basis-theory/web-elements';
+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 declare const CardElement: React.ForwardRefExoticComponent<CardElementProps & React.RefAttributes<ICardElement>>;
+export type { CardElementProps };