@basis-theory/web-elements 1.5.0 → 1.7.0

package/dist/types/index.d.ts

@@ -2,7 +2,7 @@ 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';
-type CreditCardType = {
+export type CreditCardType = {
     code: {
         size: number;
         name: SecurityCodeLabel | string;
@@ -13,6 +13,19 @@ type CreditCardType = {
     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[];
 interface RequestConfig {
     headers?: Record<string, string>;
 }
@@ -24,24 +37,33 @@ interface HttpClient {
     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 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"];
-type FieldErrorType = 'incomplete' | 'invalid';
-interface Targeted {
+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;
 }
-type ListenableKey = 'Escape' | 'Enter';
-interface FieldError {
+export type ListenableKey = 'Escape' | 'Enter';
+export interface FieldError {
     targetId: string;
     type: FieldErrorType;
 }
-interface ElementMetadata {
+export interface PropertyError {
+    type: FieldErrorType;
+}
+export interface ElementMetadata {
     complete: boolean;
     valid: boolean;
     maskSatisfied?: boolean;
     empty: boolean;
     errors?: FieldError[] | Omit<FieldError, 'targetId'>[];
 }
-interface CardMetadata {
+export interface CardMetadata {
     cardBrand: Brand;
     cardLast4?: string;
     cardBin?: string;
@@ -49,87 +71,93 @@ interface CardMetadata {
 /**
  * Card brands type
  */
-type Brand = typeof CARD_BRANDS[number];
+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
  */
-type AutoCompleteValue = typeof AUTOCOMPLETE_VALUES[number];
+export type AutoCompleteValue = typeof AUTOCOMPLETE_VALUES[number];
 /**
  * Type used for detokenization responses stored on Data Elements
  */
-type DataElementReference = {
+export type DataElementReference = {
     correlationId: string;
     elementId: string;
     path: string;
 };
-type EventType = 'ready' | 'change' | 'focus' | 'blur' | 'keydown';
-interface BaseEvent<T extends EventType> {
+export type EventType = 'ready' | 'change' | 'focus' | 'blur' | 'keydown';
+export interface BaseEvent<T extends EventType> {
     type: T;
 }
-type ReadyEvent = BaseEvent<'ready'>;
-type ChangeEvent = BaseEvent<'change'> & {
+export type ReadyEvent = BaseEvent<'ready'>;
+export type ChangeEvent = BaseEvent<'change'> & {
     empty: boolean;
     complete: boolean;
     valid?: boolean;
     maskSatisfied?: boolean;
     errors?: FieldError[];
 };
-type CardChangeEvent = ChangeEvent & {
+export type CardChangeEvent = ChangeEvent & {
     cardBrand: Brand;
     cardLast4?: string;
     cardBin?: string;
 };
-type InputFocusEvent = BaseEvent<'focus'> & Targeted;
-type InputBlurEvent = BaseEvent<'blur'> & Targeted;
-type InputKeydownEvent = BaseEvent<'keydown'> & Targeted & {
+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'>;
-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;
+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;
-type ElementEventListener<Events, Type> = (event: FindByType<Events, Type>) => void;
-interface Subscription {
+export type ElementEventListener<Events, Type> = (event: FindByType<Events, Type>) => void;
+export 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];
+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;
-type FontSources = FontSource[];
-type Fonts = Record<CardElementStyleFontAttr, FontSources>;
-type CardElementStyle = Partial<Record<CardElementStyleVariant, CardElementStyleVariantStyle> & Fonts>;
-type ElementStyle = CardElementStyle;
-type CopyIconStyles = {
+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;
 };
-declare const ELEMENTS_TYPES: readonly ["card", "cardExpirationDate", "cardNumber", "cardVerificationCode", "data", "text"];
-type ElementType = typeof ELEMENTS_TYPES[number];
-interface ElementInternalOptions {
+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;
 }
-enum InputMode {
+export enum InputMode {
     DECIMAL = "decimal",
     EMAIL = "email",
     NONE = "none",
@@ -139,7 +167,7 @@ enum InputMode {
     TEXT = "text",
     URL = "url"
 }
-interface SanitizedElementOptions {
+export interface SanitizedElementOptions {
     ariaDescription?: string;
     ariaLabel?: string;
     autoComplete?: AutoCompleteValue;
@@ -163,56 +191,56 @@ interface SanitizedElementOptions {
     validation?: RegExp;
     value?: CardElementValue<'static'> | CardExpirationDateValue<'static'> | string;
 }
-type ElementOptions = ElementInternalOptions & SanitizedElementOptions;
-type Transform = RegExp | [RegExp, string?] | null;
+export type ElementOptions = ElementInternalOptions & SanitizedElementOptions;
+export 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;
+export type CustomizableElementOptions = Pick<ElementOptions, 'cardTypes' | 'copyIconStyles' | 'disabled' | 'enableCopy' | 'inputMode' | 'readOnly' | 'skipLuhnValidation' | 'style' | 'validateOnChange'> & AutoCompleteOption;
 type ElementValueType = 'static' | 'reference';
-interface CardElementValue<T extends ElementValueType> {
+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;
 }
-interface CardElementPlaceholder {
+export interface CardElementPlaceholder {
     cardNumber?: string;
     cardExpirationDate?: string;
     cardSecurityCode?: string;
 }
-interface CardExpirationDateValue<T extends ElementValueType> {
+export interface CardExpirationDateValue<T extends ElementValueType> {
     month: T extends 'reference' ? DataElementReference : number;
     year: T extends 'reference' ? DataElementReference : number;
 }
-type CreateCardElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'cardTypes' | 'skipLuhnValidation'> & {
+export 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'>> & {
+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;
 };
-type UpdateTextElementOptions = Omit<CreateTextElementOptions, 'targetId' | 'mask' | 'validateOnChange'>;
-type CreateCardNumberElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder' | 'iconPosition' | 'cardTypes' | 'skipLuhnValidation'> & Required<Pick<ElementOptions, 'targetId'>> & {
+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;
 };
-type UpdateCardNumberElementOptions = Omit<CreateCardNumberElementOptions, 'targetId' | 'validateOnChange' | 'enableCopy'>;
-type CreateCardExpirationDateElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder'> & Required<Pick<ElementOptions, 'targetId'>> & {
+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;
 };
-type UpdateCardExpirationDateElementOptions = Omit<CreateCardExpirationDateElementOptions, 'targetId' | 'validateOnChange' | 'enableCopy'>;
-type CreateCardVerificationCodeElementOptions = CustomizableElementOptions & Pick<ElementOptions, 'placeholder' | 'cardBrand'> & Required<Pick<ElementOptions, 'targetId'>> & {
+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;
 };
-type UpdateCardVerificationCodeElementOptions = Omit<CreateCardVerificationCodeElementOptions, 'targetId' | 'validateOnChange' | 'enableCopy'>;
+export type UpdateCardVerificationCodeElementOptions = Omit<CreateCardVerificationCodeElementOptions, 'targetId' | 'validateOnChange' | 'enableCopy'>;
 interface BinDetails {
     cardBrand?: string;
     type?: string;
@@ -308,11 +336,11 @@ type Token<DataType = Primitive> = TokenBase<DataType> & {
     fingerprint?: string;
     metadata?: Record<string, string>;
 };
-type CreateToken<DataType = Primitive> = Pick<Token<DataType>, 'type' | 'data' | 'privacy' | 'containers' | 'metadata' | 'encryption' | 'searchIndexes' | 'fingerprintExpression' | 'mask' | 'expiresAt'> & {
+type _CreateToken1<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'> & {
+type _UpdateToken1<DataType = Primitive> = Partial<Pick<Token<DataType>, 'data' | 'containers' | 'metadata' | 'encryption' | 'searchIndexes' | 'fingerprintExpression' | 'mask' | 'expiresAt'> & {
     privacy: Omit<TokenPrivacy, 'classification'>;
     deduplicateToken: boolean;
 }>;
@@ -320,7 +348,7 @@ 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>;
+type _TokenizeData1<DataType = Primitive> = TokenizeArray<DataType> | TokenizeObject<DataType>;
 interface TokenIntentCardDetails {
     type: 'card';
     card: {
@@ -346,7 +374,7 @@ type TokenIntent<DataType = DataObject> = (TokenBase<DataType> & Omit<Auditable,
 }) & (TokenTypeMap[TokenTypesForTokenIntents] | TokenIntentCardDetails | {
     type: 'token';
 });
-type CreateTokenIntent<DataType = DataObject> = Pick<TokenIntent<DataType>, 'type' | 'data'>;
+type _CreateTokenIntent1<DataType = DataObject> = Pick<TokenIntent<DataType>, 'type' | 'data'>;
 interface RequestOptions {
     apiKey?: string;
     correlationId?: string;
@@ -361,13 +389,13 @@ type Retrieve<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>;
+export type TokenizeData = _TokenizeData1<ElementValue>;
+export interface Tokenize {
+    tokenize(tokens: TokenizeData, options?: RequestOptions): Promise<_TokenizeData1>;
 }
-type _CreateToken1 = CreateToken<ElementValue>;
-type _UpdateToken1 = UpdateToken<ElementValue>;
-type Tokens = Create<Token, _CreateToken1> & Retrieve<Token<unknown>> & Update<Token, _UpdateToken1>;
+export type CreateToken = _CreateToken1<ElementValue>;
+export type UpdateToken = _UpdateToken1<ElementValue>;
+export type Tokens = Create<Token, CreateToken> & Retrieve<Token<unknown>> & Update<Token, UpdateToken>;
 type BasisTheoryProxyHeaders = {
     [key: string]: string;
     'BT-PROXY-URL': string;
@@ -379,23 +407,32 @@ type BasisTheoryQueryParams = {
     'bt-proxy-key': string;
 };
 type ProxyQuery = Partial<BasisTheoryQueryParams>;
-interface ProxyRequestOptions extends RequestOptions {
+export interface ProxyRequestOptions extends RequestOptions {
     includeResponseHeaders?: boolean;
     path?: string;
     query?: ProxyQuery;
     headers?: ProxyHeaders;
     body?: unknown;
 }
-interface Proxy {
+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>;
 }
-type _CreateTokenIntent1 = CreateTokenIntent<ElementValue>;
-type TokenIntents = Create<TokenIntent, _CreateTokenIntent1>;
-interface BaseElement<UpdateOptions, ElementEvents> {
+export type CreateTokenIntent = _CreateTokenIntent1<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>;
@@ -407,42 +444,43 @@ interface BaseElement<UpdateOptions, ElementEvents> {
     unmount(): void;
     on<T extends EventType>(eventType: T, listener: ElementEventListener<ElementEvents, T>): Subscription;
 }
-type CardElement = BaseElement<UpdateCardElementOptions, CardElementEvents> & {
+export type CardElement = BaseElement<UpdateCardElementOptions, CardElementEvents> & {
     readonly cardMetadata?: CardMetadata;
     setValue(value: CardElementValue<'reference'>): void;
     validate(): void;
 };
-type TextElement = BaseElement<UpdateTextElementOptions, TextElementEvents> & {
+export type TextElement = BaseElement<UpdateTextElementOptions, TextElementEvents> & {
     setValueRef(value: TextElement): void;
     setValue(value: DataElementReference): void;
 };
-type CardNumberElement = BaseElement<UpdateCardNumberElementOptions, CardNumberElementEvents> & {
+export type CardNumberElement = BaseElement<UpdateCardNumberElementOptions, CardNumberElementEvents> & {
     readonly cardMetadata?: CardMetadata;
     setValueRef(value: CardNumberElement): void;
     setValue(value: DataElementReference): void;
 };
-type CardExpirationDateElement = BaseElement<UpdateCardExpirationDateElementOptions, CardExpirationDateElementEvents> & {
+export type CardExpirationDateElement = BaseElement<UpdateCardExpirationDateElementOptions, CardExpirationDateElementEvents> & {
     setValueRef(value: CardExpirationDateElement): void;
     setValue(value: CardExpirationDateValue<'reference'>): void;
     month(): ElementWrapper<CardExpirationDateElement>;
     year(): ElementWrapper<CardExpirationDateElement>;
     format(dateFormat: string): ElementWrapper<CardExpirationDateElement>;
 };
-type CardVerificationCodeElement = BaseElement<UpdateCardVerificationCodeElementOptions, CardVerificationCodeElementEvents> & {
+export type CardVerificationCodeElement = BaseElement<UpdateCardVerificationCodeElementOptions, CardVerificationCodeElementEvents> & {
     setValueRef(value: CardVerificationCodeElement): void;
     setValue(value: DataElementReference): void;
 };
-type ElementWrapper<T extends BaseElement<any, any> = BaseElement<any, any>> = {
+export type ElementWrapper<T extends BaseElement<any, any> = BaseElement<any, any>> = {
     element: T;
     method?: string;
     formattingOptions?: {
         format: string;
     };
 };
-type ElementValue = TextElement | CardElement | CardNumberElement | CardExpirationDateElement | CardVerificationCodeElement | ElementWrapper;
-interface BasisTheoryElements {
+export type ElementValue = TextElement | CardElement | CardNumberElement | CardExpirationDateElement | CardVerificationCodeElement | ElementWrapper;
+export interface BasisTheoryElements {
     tokens: Tokens;
     proxy: Proxy;
+    sessions: Sessions;
     tokenIntents: TokenIntents;
     tokenize: Tokenize;
     client: HttpClient;
@@ -452,6 +490,10 @@ interface BasisTheoryElements {
     createElement(type: 'cardExpirationDate', options: CreateCardExpirationDateElementOptions): CardExpirationDateElement;
     createElement(type: 'cardVerificationCode', options: CreateCardVerificationCodeElementOptions): CardVerificationCodeElement;
 }
+export interface BasisTheoryElementsInternal extends BasisTheoryElements {
+    init: (apiKey: string | undefined, elementsBaseUrl: string, elementsUseNgApi: boolean | undefined, disableTelemetry: boolean | undefined, elementsUseSameOriginApi: boolean | undefined) => Promise<BasisTheoryElements>;
+    hasElement: (payload: unknown) => boolean;
+}
 declare global {
     interface Window {
         BasisTheoryElements?: BasisTheoryElementsInternal;

package/dist/types/{common → src/common}/BasisTheoryValidationError.d.ts

@@ -1,4 +1,4 @@
-import type { FieldError } from '~/types/elements';
+import type { FieldError } from '../types/elements';
 export declare class BasisTheoryValidationError<Details = Record<string, unknown>> extends Error {
     readonly details: Details;
     /**

package/dist/types/{elements → src/elements}/loadElements.d.ts

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

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

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

package/dist/types/{types → src/types}/elements/elements.d.ts

@@ -1,8 +1,9 @@
-import type { HttpClient } from '~/types/sdk';
+import type { HttpClient } from '../../types/sdk';
 import type { CardElementEvents, CardExpirationDateElementEvents, CardNumberElementEvents, CardVerificationCodeElementEvents, ElementEventListener, EventType, Subscription, TextElementEvents } from './events';
 import type { CardElementValue, CardExpirationDateValue, CreateCardElementOptions, CreateCardExpirationDateElementOptions, CreateCardNumberElementOptions, CreateCardVerificationCodeElementOptions, CreateTextElementOptions, UpdateCardElementOptions, UpdateCardExpirationDateElementOptions, UpdateCardNumberElementOptions, UpdateCardVerificationCodeElementOptions, UpdateTextElementOptions } from './options';
 import type { Proxy, Tokenize, Tokens, TokenIntents } from './services';
 import type { CardMetadata, DataElementReference, ElementMetadata } from './shared';
+import { Sessions } from './services/sessions';
 interface BaseElement<UpdateOptions, ElementEvents> {
     readonly mounted: boolean;
     readonly metadata: ElementMetadata;
@@ -51,6 +52,7 @@ type ElementValue = TextElement | CardElement | CardNumberElement | CardExpirati
 interface BasisTheoryElements {
     tokens: Tokens;
     proxy: Proxy;
+    sessions: Sessions;
     tokenIntents: TokenIntents;
     tokenize: Tokenize;
     client: HttpClient;

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

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

package/dist/types/{types → src/types}/elements/services/token-intents.d.ts

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

package/dist/types/{types → src/types}/elements/services/tokenize.d.ts

@@ -1,5 +1,5 @@
-import type { ElementValue } from '~/types/elements';
-import type { TokenizeData as TokenizeDataModel } from '~/types/models';
+import type { ElementValue } from '../';
+import type { TokenizeData as TokenizeDataModel } from '../../models';
 import { RequestOptions } from './shared';
 type TokenizeData = TokenizeDataModel<ElementValue>;
 interface Tokenize {

package/dist/types/{types → src/types}/elements/services/tokens.d.ts

@@ -1,5 +1,5 @@
-import type { ElementValue } from '~/types/elements';
-import type { CreateToken as CreateTokenModel, UpdateToken as UpdateTokenModel, Token } from '~/types/models';
+import type { ElementValue } from '../../elements';
+import type { CreateToken as CreateTokenModel, UpdateToken as UpdateTokenModel, Token } from '../../models';
 import { Create, Retrieve, Update } from './shared';
 type CreateToken = CreateTokenModel<ElementValue>;
 type UpdateToken = UpdateTokenModel<ElementValue>;

package/dist/types/{types → src/types}/elements/shared.d.ts

@@ -1,4 +1,4 @@
-import { AUTOCOMPLETE_VALUES, CARD_BRANDS, CARD_ICON_POSITIONS } from '~/elements/constants';
+import { AUTOCOMPLETE_VALUES, CARD_BRANDS, CARD_ICON_POSITIONS } from '../../elements/constants';
 type FieldErrorType = 'incomplete' | 'invalid';
 type ConfigErrorType = 'missing-configuration' | 'missing-permission' | 'invalid-configuration';
 interface ConfigError {

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

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

package/dist/types/{types → src/types}/models/token-intents.d.ts

@@ -1,4 +1,4 @@
-import type { TokenBase, DataObject, Auditable, TokenType } from '~/types/models';
+import type { TokenBase, DataObject, Auditable, TokenType } from '../../types/models';
 interface TokenIntentCardDetails {
     type: 'card';
     card: {

package/dist/types/src/version.d.ts

@@ -0,0 +1 @@
+export const version: "1.7.0";