@basis-theory/react-elements 1.11.3 → 1.11.4

package/main/index.js

@@ -1,5 +1,5 @@
-var $6ZdRe$basistheorywebelements = require("@basis-theory/web-elements");
 var $6ZdRe$react = require("react");
+var $6ZdRe$basistheorywebelements = require("@basis-theory/web-elements");
 var $6ZdRe$reactjsxruntime = require("react/jsx-runtime");
 
 
@@ -27,21 +27,6 @@ function $parcel$export(e, n, v, s) {
 function $parcel$interopDefault(a) {
   return a && a.__esModule ? a.default : a;
 }
-
-$parcel$export(module.exports, "AMERICAN_EXPRESS", () => $6ZdRe$basistheorywebelements.AMERICAN_EXPRESS);
-$parcel$export(module.exports, "DEFAULT_CARD_TYPES", () => $6ZdRe$basistheorywebelements.DEFAULT_CARD_TYPES);
-$parcel$export(module.exports, "DINERS_CLUB", () => $6ZdRe$basistheorywebelements.DINERS_CLUB);
-$parcel$export(module.exports, "DISCOVER", () => $6ZdRe$basistheorywebelements.DISCOVER);
-$parcel$export(module.exports, "ELO", () => $6ZdRe$basistheorywebelements.ELO);
-$parcel$export(module.exports, "HIPER", () => $6ZdRe$basistheorywebelements.HIPER);
-$parcel$export(module.exports, "HIPERCARD", () => $6ZdRe$basistheorywebelements.HIPERCARD);
-$parcel$export(module.exports, "JCB", () => $6ZdRe$basistheorywebelements.JCB);
-$parcel$export(module.exports, "MAESTRO", () => $6ZdRe$basistheorywebelements.MAESTRO);
-$parcel$export(module.exports, "MASTERCARD", () => $6ZdRe$basistheorywebelements.MASTERCARD);
-$parcel$export(module.exports, "MIR", () => $6ZdRe$basistheorywebelements.MIR);
-$parcel$export(module.exports, "UNION_PAY", () => $6ZdRe$basistheorywebelements.UNION_PAY);
-$parcel$export(module.exports, "VISA", () => $6ZdRe$basistheorywebelements.VISA);
-$parcel$export(module.exports, "CARD_BRANDS", () => $6ZdRe$basistheorywebelements.CARD_BRANDS);
 var $a6b9dd675f852902$exports = {};
 
 $parcel$export($a6b9dd675f852902$exports, "useBasisTheory", () => $311cac811dba7e3c$export$8855c0c49ada8fa3);
@@ -254,7 +239,7 @@ function CardElement(props, ref) {
 
 
 
-const $5056c1f1f96da4b6$var$TextElementC = ({ 'aria-label': ariaLabel, autoComplete: autoComplete, bt: bt, disabled: disabled, elementRef: elementRef, id: id, inputMode: inputMode, mask: mask, maxLength: maxLength, onBlur: onBlur, onChange: onChange, onFocus: onFocus, onKeyDown: onKeyDown, onReady: onReady, password: password, placeholder: placeholder, readOnly: readOnly, style: style, transform: transform, validation: validation, value: value, valueRef: valueRef })=>{
+const $5056c1f1f96da4b6$var$TextElementC = ({ 'aria-label': ariaLabel, autoComplete: autoComplete, bt: bt, disabled: disabled, elementRef: elementRef, id: id, inputMode: inputMode, mask: mask, maxLength: maxLength, onBlur: onBlur, onChange: onChange, onFocus: onFocus, onKeyDown: onKeyDown, onReady: onReady, password: password, placeholder: placeholder, readOnly: readOnly, style: style, transform: transform, validateOnChange: validateOnChange, validation: validation, value: value, valueRef: valueRef })=>{
     const wrapperRef = (0, $6ZdRe$react.useRef)(null);
     const element = (0, $515e46363124517b$export$93e1bc7222cfbdc8)(id, 'text', wrapperRef, {
         'aria-label': ariaLabel,
@@ -269,6 +254,7 @@ const $5056c1f1f96da4b6$var$TextElementC = ({ 'aria-label': ariaLabel, autoCompl
         style: style,
         targetId: id,
         transform: transform,
+        validateOnChange: validateOnChange,
         validation: validation,
         value: value
     }, bt, elementRef, valueRef);
@@ -411,8 +397,11 @@ const $9bb5cbc1cc445953$export$36d668a024913c87 = /*#__PURE__*/ (0, ($parcel$int
 
 
 
+var $155b7e20af39b8bd$exports = {};
+
 
 $parcel$exportWildcard(module.exports, $a6b9dd675f852902$exports);
 $parcel$exportWildcard(module.exports, $09db7b15c2691edc$exports);
+$parcel$exportWildcard(module.exports, $155b7e20af39b8bd$exports);
 
 

package/module/module.js

@@ -1,5 +1,5 @@
-import {AMERICAN_EXPRESS as $8fc858ffa1007a27$re_export$AMERICAN_EXPRESS, DEFAULT_CARD_TYPES as $8fc858ffa1007a27$re_export$DEFAULT_CARD_TYPES, DINERS_CLUB as $8fc858ffa1007a27$re_export$DINERS_CLUB, DISCOVER as $8fc858ffa1007a27$re_export$DISCOVER, ELO as $8fc858ffa1007a27$re_export$ELO, HIPER as $8fc858ffa1007a27$re_export$HIPER, HIPERCARD as $8fc858ffa1007a27$re_export$HIPERCARD, JCB as $8fc858ffa1007a27$re_export$JCB, MAESTRO as $8fc858ffa1007a27$re_export$MAESTRO, MASTERCARD as $8fc858ffa1007a27$re_export$MASTERCARD, MIR as $8fc858ffa1007a27$re_export$MIR, UNION_PAY as $8fc858ffa1007a27$re_export$UNION_PAY, VISA as $8fc858ffa1007a27$re_export$VISA, CARD_BRANDS as $8fc858ffa1007a27$re_export$CARD_BRANDS, basistheory as $gb0K4$basistheory} from "@basis-theory/web-elements";
 import $gb0K4$react, {useState as $gb0K4$useState, useRef as $gb0K4$useRef, useEffect as $gb0K4$useEffect, createContext as $gb0K4$createContext, useMemo as $gb0K4$useMemo, useContext as $gb0K4$useContext} from "react";
+import {basistheory as $gb0K4$basistheory} from "@basis-theory/web-elements";
 import {jsx as $gb0K4$jsx} from "react/jsx-runtime";
 
 
@@ -218,7 +218,7 @@ function CardElement(props, ref) {
 
 
 
-const $098244fc1ecf3b22$var$TextElementC = ({ 'aria-label': ariaLabel, autoComplete: autoComplete, bt: bt, disabled: disabled, elementRef: elementRef, id: id, inputMode: inputMode, mask: mask, maxLength: maxLength, onBlur: onBlur, onChange: onChange, onFocus: onFocus, onKeyDown: onKeyDown, onReady: onReady, password: password, placeholder: placeholder, readOnly: readOnly, style: style, transform: transform, validation: validation, value: value, valueRef: valueRef })=>{
+const $098244fc1ecf3b22$var$TextElementC = ({ 'aria-label': ariaLabel, autoComplete: autoComplete, bt: bt, disabled: disabled, elementRef: elementRef, id: id, inputMode: inputMode, mask: mask, maxLength: maxLength, onBlur: onBlur, onChange: onChange, onFocus: onFocus, onKeyDown: onKeyDown, onReady: onReady, password: password, placeholder: placeholder, readOnly: readOnly, style: style, transform: transform, validateOnChange: validateOnChange, validation: validation, value: value, valueRef: valueRef })=>{
     const wrapperRef = (0, $gb0K4$useRef)(null);
     const element = (0, $001f9ef7a572da43$export$93e1bc7222cfbdc8)(id, 'text', wrapperRef, {
         'aria-label': ariaLabel,
@@ -233,6 +233,7 @@ const $098244fc1ecf3b22$var$TextElementC = ({ 'aria-label': ariaLabel, autoCompl
         style: style,
         targetId: id,
         transform: transform,
+        validateOnChange: validateOnChange,
         validation: validation,
         value: value
     }, bt, elementRef, valueRef);
@@ -375,7 +376,9 @@ const $6f922196262b492d$export$36d668a024913c87 = /*#__PURE__*/ (0, $gb0K4$react
 
 
 
+var $17e03523eeef3efb$exports = {};
+
 
 
 
-export {$8fc858ffa1007a27$re_export$AMERICAN_EXPRESS as AMERICAN_EXPRESS, $8fc858ffa1007a27$re_export$DEFAULT_CARD_TYPES as DEFAULT_CARD_TYPES, $8fc858ffa1007a27$re_export$DINERS_CLUB as DINERS_CLUB, $8fc858ffa1007a27$re_export$DISCOVER as DISCOVER, $8fc858ffa1007a27$re_export$ELO as ELO, $8fc858ffa1007a27$re_export$HIPER as HIPER, $8fc858ffa1007a27$re_export$HIPERCARD as HIPERCARD, $8fc858ffa1007a27$re_export$JCB as JCB, $8fc858ffa1007a27$re_export$MAESTRO as MAESTRO, $8fc858ffa1007a27$re_export$MASTERCARD as MASTERCARD, $8fc858ffa1007a27$re_export$MIR as MIR, $8fc858ffa1007a27$re_export$UNION_PAY as UNION_PAY, $8fc858ffa1007a27$re_export$VISA as VISA, $8fc858ffa1007a27$re_export$CARD_BRANDS as CARD_BRANDS, $af3ff746464f54fa$export$8855c0c49ada8fa3 as useBasisTheory, $45f18da36523d589$export$e61fbf0ee83adc05 as BasisTheoryProvider, $22a85849b67e3ab0$export$642653cabb64aed9 as CardElement, $098244fc1ecf3b22$export$764077542c4bf9bd as TextElement, $c9d0638264a6246e$export$a2311b18160d2f3f as CardNumberElement, $b04bbbda03b8923f$export$d5128efc3cebc889 as CardExpirationDateElement, $6f922196262b492d$export$36d668a024913c87 as CardVerificationCodeElement};
+export {$af3ff746464f54fa$export$8855c0c49ada8fa3 as useBasisTheory, $45f18da36523d589$export$e61fbf0ee83adc05 as BasisTheoryProvider, $22a85849b67e3ab0$export$642653cabb64aed9 as CardElement, $098244fc1ecf3b22$export$764077542c4bf9bd as TextElement, $c9d0638264a6246e$export$a2311b18160d2f3f as CardNumberElement, $b04bbbda03b8923f$export$d5128efc3cebc889 as CardExpirationDateElement, $6f922196262b492d$export$36d668a024913c87 as CardVerificationCodeElement};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basis-theory/react-elements",
-  "version": "1.11.3",
+  "version": "1.11.4",
   "repository": "https://github.com/basis-theory/react-elements",
   "license": "Apache-2.0",
   "author": {
@@ -15,10 +15,9 @@
     "!/bundle"
   ],
   "scripts": {
-    "build:dev": "yarn clean && parcel build && yarn generateTypes && npx size-limit",
-    "build": "node ../scripts/react-elements/prepare.js && parcel build --no-cache && yarn generateTypes",
+    "build:dev": "yarn clean && parcel build && npx size-limit",
+    "build": "node ../scripts/react-elements/prepare.js && parcel build --no-cache",
     "clean": "rimraf dist .parcel-cache",
-    "generateTypes": "tsc --emitDeclarationOnly",
     "lint-staged": "lint-staged",
     "lint:fix": "eslint --fix",
     "lint": "eslint",
@@ -31,7 +30,7 @@
     "tag": "latest"
   },
   "dependencies": {
-    "@basis-theory/web-elements": "1.11.3"
+    "@basis-theory/web-elements": "1.11.4"
   },
   "peerDependencies": {
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0",

package/types/index.d.ts

@@ -1,4 +1,682 @@
-export * from './core';
-export * from './elements';
-export type { BasisTheoryElements } from '@basis-theory/web-elements';
-export { AMERICAN_EXPRESS, DEFAULT_CARD_TYPES, DINERS_CLUB, DISCOVER, ELO, HIPER, HIPERCARD, JCB, MAESTRO, MASTERCARD, MIR, UNION_PAY, VISA, CARD_BRANDS, } from '@basis-theory/web-elements';
+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>>;

package/types/core/BasisTheoryProvider.d.ts

@@ -1,11 +0,0 @@
-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/types/core/index.d.ts

@@ -1,2 +0,0 @@
-export { useBasisTheory } from './useBasisTheory';
-export { BasisTheoryProvider } from './BasisTheoryProvider';

package/types/core/useBasisTheory.d.ts

@@ -1,9 +0,0 @@
-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/types/elements/CardElement.d.ts

@@ -1,25 +0,0 @@
-import React from 'react';
-import type { BasisTheoryElements, CardElement as ICardElement, CardElementEvents, CardElementPlaceholder, CardElementValue, CopyIconStyles, CreateCardElementOptions, CreditCardType, ElementEventListener, ElementStyle, InputMode } 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 };

package/types/elements/CardExpirationDateElement.d.ts

@@ -1,25 +0,0 @@
-import React, { MutableRefObject } from 'react';
-import type { BasisTheoryElements, CardExpirationDateElement as ICardExpirationDateElement, CardExpirationDateElementEvents, CardExpirationDateValue, CopyIconStyles, CreateCardExpirationDateElementOptions, ElementEventListener, ElementStyle, InputMode } 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/types/elements/CardNumberElement.d.ts

@@ -1,28 +0,0 @@
-import React, { MutableRefObject } from 'react';
-import type { BasisTheoryElements, CardNumberElement as ICardNumberElement, CardNumberElementEvents, CopyIconStyles, CreateCardNumberElementOptions, CreditCardType, ElementEventListener, ElementStyle, InputMode, SanitizedElementOptions } 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/types/elements/CardVerificationCodeElement.d.ts

@@ -1,26 +0,0 @@
-import React, { MutableRefObject } from 'react';
-import type { BasisTheoryElements, Brand, CardVerificationCodeElement as ICardVerificationCodeElement, CardVerificationCodeElementEvents, CopyIconStyles, CreateCardVerificationCodeElementOptions, ElementEventListener, ElementStyle, InputMode } 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/types/elements/TextElement.d.ts

@@ -1,34 +0,0 @@
-import React, { MutableRefObject } from 'react';
-import type { BasisTheoryElements, CreateTextElementOptions, ElementEventListener, ElementStyle, InputMode, TextElement as ITextElement, TextElementEvents } 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/types/elements/index.d.ts

@@ -1,10 +0,0 @@
-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/types/elements/useBasisTheoryValue.d.ts

@@ -1,10 +0,0 @@
-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/types/elements/useElement.d.ts

@@ -1,15 +0,0 @@
-import React, { ForwardedRef, MutableRefObject } from 'react';
-import type { BaseElement, BasisTheoryElements, ElementType } 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/types/elements/useListener.d.ts

@@ -1,3 +0,0 @@
-import type { BaseElement, ElementEventListener, EventType } from '@basis-theory/web-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/types/types.d.ts

@@ -1 +0,0 @@
-export type * from '@basis-theory/web-elements';