@basis-theory/web-elements 1.11.2 → 1.11.4

package/dist/types/index.d.ts

@@ -1,8 +1,546 @@
-import { basistheory } from './BasisTheory';
+import { Properties } from "csstype";
+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;
     }
 }
-export * from './BasisTheory';
-export * from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basis-theory/web-elements",
-  "version": "1.11.2",
+  "version": "1.11.4",
   "repository": "https://github.com/basis-theory/web-elements",
   "license": "Apache-2.0",
   "author": {
@@ -16,10 +16,9 @@
   ],
   "scripts": {
     "prebuild": "TARGET_DIR=../../web-elements/src node ../scripts/web-elements/write-version-file.js",
-    "build:dev": "yarn clean && parcel build && yarn generateTypes && npx size-limit && yarn generate-sri",
-    "build": "node ../scripts/web-elements/prepare.js && parcel build --no-cache && yarn generateTypes && yarn generate-sri",
+    "build:dev": "yarn clean && parcel build && npx size-limit && yarn generate-sri",
+    "build": "node ../scripts/web-elements/prepare.js && parcel build --no-cache && yarn generate-sri",
     "clean": "rimraf dist .parcel-cache",
-    "generateTypes": "tsc --emitDeclarationOnly",
     "generate-sri": "node ../scripts/web-elements/generate-sri.js",
     "lint-staged": "lint-staged",
     "lint:fix": "eslint --fix",
@@ -73,11 +72,10 @@
     }
   ],
   "devDependencies": {
-    "@parcel/packager-ts": "2.13.2",
-    "@parcel/transformer-typescript-types": "2.13.2",
+    "@parcel/packager-ts": "2.14.2",
+    "@parcel/transformer-typescript-types": "2.14.2",
     "@size-limit/preset-small-lib": "^11.1.6",
-    "parcel": "^2.13.2",
-    "ts-jest": "^29.2.5",
-    "typescript": "^5.7.2"
+    "parcel": "^2.14.2",
+    "ts-jest": "^29.2.5"
   }
 }

package/dist/types/BasisTheory.d.ts

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

package/dist/types/common/BasisTheoryApiError.d.ts

@@ -1,5 +0,0 @@
-export declare class BasisTheoryApiError extends Error {
-    readonly status: number;
-    readonly data?: unknown | undefined;
-    constructor(message: string, status: number, data?: unknown | undefined);
-}

package/dist/types/common/BasisTheoryValidationError.d.ts

@@ -1,13 +0,0 @@
-import type { FieldError } from '../types/elements';
-export declare class BasisTheoryValidationError<Details = Record<string, unknown>> extends Error {
-    readonly details: Details;
-    /**
-     * @deprecated use {@link details}
-     */
-    readonly validation?: FieldError[] | undefined;
-    constructor(message: string, details: Details, 
-    /**
-     * @deprecated use {@link details}
-     */
-    validation?: FieldError[] | undefined);
-}

package/dist/types/common/HttpClientError.d.ts

@@ -1,6 +0,0 @@
-export declare class HttpClientError extends Error {
-    readonly status: number;
-    readonly data?: unknown;
-    readonly headers?: unknown;
-    constructor(message: string, status: number, data?: unknown, headers?: unknown);
-}

package/dist/types/common/index.d.ts

@@ -1,3 +0,0 @@
-export { BasisTheoryApiError } from './BasisTheoryApiError';
-export { BasisTheoryValidationError } from './BasisTheoryValidationError';
-export { HttpClientError } from './HttpClientError';

package/dist/types/common/logging.d.ts

@@ -1,8 +0,0 @@
-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/elements/constants.d.ts

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

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

package/dist/types/elements/index.d.ts

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

package/dist/types/elements/loadElements.d.ts

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