@notabene/javascript-sdk 2.0.0-next.10 → 2.0.0-next.12

package/dist/notabene.d.ts

@@ -1,6 +1,7 @@
 /**
- * 5.2.6
  * Address
+ * Represents a physical address
+ * @public
  */
 declare type Address = {
     /** Identifies the nature of the address. */
@@ -34,16 +35,13 @@ declare type Address = {
     /** Information that locates and identifies a specific address, presented in free format text. */
     addressLine?: string[];
     /** Nation with its own government. */
-    country: string;
+    country: ISOCountryCode;
 };
 
 /**
- * 5.3.11
- * AddressTypeCode
- *
- * `HOME` Residential - Address is the home address.
- * `BIZZ` Business - Address is the business address.
- * `GEOG` Geographic - Address is the unspecified physical (geographical) address suitable for identification of the natural or legal person.
+ * Address Type Code
+ * Specifies the type of address
+ * @public
  */
 declare type AddressTypeCode = 'HOME' | 'BIZZ' | 'GEOG';
 
@@ -54,8 +52,8 @@ declare type AddressTypeCode = 'HOME' | 'BIZZ' | 'GEOG';
 export declare interface Agent {
     did: DID;
     type: AgentType;
-    logo?: string;
-    url?: string;
+    logo?: URI;
+    url?: URI;
     name?: string;
     verified?: boolean;
 }
@@ -70,51 +68,88 @@ export declare enum AgentType {
 }
 
 /**
- * 6.3
- * The beneficiary is defined in Section 1.1 as the natural or legal person or legal arrangement who is identified by the originator as the receiver of the requested VA transfer.
+ * Beneficiary
+ * Represents the receiver of the requested VA transfer
+ * @public
  */
 declare type Beneficiary = {
+    /** Array of persons associated with the beneficiary */
     beneficiaryPersons?: Person[];
+    /** Array of account numbers, maximum 100 characters each */
     accountNumber?: string[];
 };
 
+/**
+ * Fields specific to the beneficiary of a transaction
+ * @public
+ */
 declare type BeneficiaryFields = {
     destination?: destination;
 };
 
 /**
- * 6.5
- * The originating VASP is defined in Section 1.1 as the VASP which initiates the VA transfer, and transfers the VA upon receiving the request for a VA transfer on behalf of the originator.
+ * Beneficiary VASP
+ * Represents the VASP which receives the VA transfer
+ * @public
  */
 declare type BeneficiaryVASP = {
+    /** The beneficiary VASP information */
     beneficiaryVASP?: Person;
 };
 
+/**
+ * A blockchain address
+ * @public
+ */
 declare type BlockchainAddress = string;
 
+/**
+ * Chain Agnostic Account Identifier
+ * Represents an account on a specific blockchain
+ * Format: `{caip2}:{address}`
+ * @example "eip155:1:0x742d35Cc6634C0532925a3b844Bc454e4438f44e" for an Ethereum account
+ * @public
+ */
 declare type CAIP10 = `${CAIP2}:${string}`;
 
+/**
+ * Chain Agnostic Asset Identifier
+ * Represents an asset on a specific blockchain
+ * Format: `{caip2}/{asset_namespace}:{asset_reference}`
+ * @example "eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f" for DAI on Ethereum
+ * @public
+ */
 declare type CAIP19 = `${CAIP2}/${string}:${string}`;
 
+/**
+ * Chain Agnostic Blockchain Identifier
+ * Represents a blockchain in a chain-agnostic way
+ * Format: `namespace:reference`
+ * @example "eip155:1" for Ethereum Mainnet
+ * @public
+ */
 declare type CAIP2 = `${string}:${string}`;
 
-declare interface CallbackOptions {
+/**
+ * Options for callback and redirect URIs
+ * @public
+ */
+export declare interface CallbackOptions {
     callback?: URI;
     redirectUri?: URI;
 }
 
+/**
+ * Represents a cancel component message
+ * @public
+ */
 declare type Cancel = {
     type: CMType.CANCEL;
 };
 
-declare type CloseModal = {
-    type: CMType.CLOSE;
-    reqid: RequestID;
-};
-
 /**
  * Component Message Types
- * @internal
+ * @public
  */
 export declare const enum CMType {
     COMPLETE = "complete",
@@ -128,16 +163,55 @@ export declare const enum CMType {
     CANCEL = "cancel"
 }
 
+/**
+ * Represents a completed component message
+ * @public
+ */
 declare type Completed = {
     type: CMType.COMPLETE;
-    response: TransactionResponse;
+    response: ComponentResponse;
 };
 
 /**
  * Component Message
- * @internal
+ * @public
+ */
+export declare type ComponentMessage = Completed | Cancel | Error_2 | Ready | ResizeRequest | InvalidValue;
+
+/**
+ * An abstract request for communicating with a component
+ * @public
  */
-export declare type ComponentMessage = Completed | Cancel | Error_2 | Result | Ready | ResizeRequest | ModalRequest | InvalidValue | CloseModal;
+declare interface ComponentRequest {
+    requestId?: RequestID;
+    customer?: Counterparty;
+}
+
+declare interface ComponentResponse {
+    requestID: RequestID;
+    valid: boolean;
+    status: Status;
+    errors: ValidationError[];
+}
+
+/**
+ * An object representing a connection request
+ * @public
+ */
+export declare interface ConnectionRequest extends ComponentRequest {
+    asset: TransactionAsset;
+}
+
+/**
+ * An object representing a connection response
+ * @public
+ */
+export declare interface ConnectionResponse extends ComponentResponse {
+    value: ConnectionRequest;
+    ivms: IVMS101;
+    proof?: OwnershipProof;
+    txCreate?: V1Transaction;
+}
 
 /**
  * The counterparty of a transaction.
@@ -146,20 +220,30 @@ export declare type ComponentMessage = Completed | Cancel | Error_2 | Result | R
 export declare interface Counterparty {
     name?: string;
     accountNumber?: string;
-    did?: string;
-    geographicAddress?: string;
+    did?: DID;
     type?: PersonType;
     verified?: boolean;
+    geographicAddress?: Address;
+    nationalIdentification?: NationalIdentification;
+    website?: URI;
+    phone?: string;
 }
 
+/**
+ * A crypto credential
+ * @public
+ */
 declare type CryptoCredential = `${string}.${string}.mastercard`;
 
 /**
- * 5.2.7
- * DateAndPlaceOfBirth
+ * Date and Place of Birth
+ * Represents the date and place of birth for a natural person
+ * @public
  */
 declare type DateAndPlaceOfBirth = {
-    dateOfBirth?: string;
+    /** Date of birth in ISO 8601 format (YYYY-MM-DD) */
+    dateOfBirth?: ISODate;
+    /** Place of birth (max 70 characters) */
     placeOfBirth?: string;
 };
 
@@ -187,8 +271,14 @@ export declare interface Deposit extends OriginatorFields, Transaction {
 export declare interface DepositRequest extends DepositRequestFields, Transaction {
 }
 
+/**
+ * Fields specific to a deposit request
+ * @public
+ */
 declare type DepositRequestFields = {
-    destinations: destination[];
+    destination: BlockchainAddress | CAIP10;
+    travelAddress?: TravelAddress;
+    cryptoCredential?: CryptoCredential;
 };
 
 /**
@@ -197,46 +287,125 @@ declare type DepositRequestFields = {
  */
 export declare type destination = BlockchainAddress | CAIP10 | CryptoCredential | TravelAddress;
 
+/**
+ * A Decentralized Identifier
+ * @public
+ */
 declare type DID = `did:${string}:${string}`;
 
+/**
+ * Digital Token Identifier
+ * @public
+ */
 declare type DTI = string;
 
 /**
  * An embedded Notabene component
  * @public
  */
-export declare class EmbeddedComponent {
+export declare class EmbeddedComponent<V, R> {
     private _url;
     private _value;
     private _errors;
     private iframe?;
     private eventManager;
-    private ready;
     private modal?;
-    constructor(url: string, value: Partial<Transaction>);
+    /**
+     * Creates an instance of EmbeddedComponent.
+     * @param url - The URL of the embedded component
+     * @param value - The initial transaction value
+     */
+    constructor(url: string, value: V);
+    /**
+     * Gets the URL of the embedded component
+     * @returns The URL of the embedded component
+     */
     get url(): string;
-    get value(): Partial<Transaction>;
+    /**
+     * Gets the current transaction value
+     * @returns The current transaction value
+     */
+    get value(): V;
     get errors(): ValidationError[];
+    /**
+     * Opens the component URL in the current window
+     */
     open(): void;
+    /**
+     * Mounts the component to a parent element
+     * @param parentId - The ID of the parent element
+     * @throws Will throw an error if the parent element is not found
+     */
     mount(parentId: string): void;
+    /**
+     * Embeds the component into a parent element
+     * @param parent - The parent element to embed the component into
+     */
     embed(parent: Element): void;
+    /**
+     * Sends a message to the embedded component
+     * @param message - The message to send
+     */
     send(message: HostMessage): void;
+    /**
+     * Adds an event listener for a specific message type
+     * @param messageType - The type of message to listen for
+     * @param callback - The callback function to execute when the message is received
+     */
     on(messageType: string, callback: MessageCallback): void;
+    /**
+     * Removes an event listener for a specific message type
+     * @param messageType - The type of message to stop listening for
+     * @param callback - The callback function to remove
+     */
     off(messageType: string, callback: MessageCallback): void;
-    update(value: Partial<Transaction>): void;
-    completion(): Promise<TransactionResponse>;
-    openModal(): void;
-    private closeModal;
+    /**
+     * Updates the transaction value and sends an update message to the component
+     * @param value - The new transaction value
+     */
+    update(value: V): void;
+    /**
+     * Waits for the component to complete and returns the transaction response
+     * @returns A promise that resolves with the transaction response
+     */
+    completion(): Promise<R>;
+    /**
+     * Opens the component in a modal dialog
+     */
+    openModal(): Promise<R>;
+    /**
+     * Closes the modal dialog
+     *
+     */
+    closeModal(): void;
 }
 
+/**
+ * Represents an error component message
+ * @public
+ */
 declare type Error_2 = {
     type: CMType.ERROR;
     message: string;
 };
 
+/**
+ * Field properties
+ * @public
+ */
+declare type FieldOptions = boolean | {
+    optional: boolean;
+    transmit: boolean;
+};
+
+declare type FieldTypes = {
+    naturalPerson?: NaturalPersonFields;
+    legalPerson?: LegalPersonFields;
+};
+
 /**
  * Host Message Types
- * @internal
+ * @public
  */
 declare const enum HMType {
     UPDATE = "update",
@@ -245,25 +414,53 @@ declare const enum HMType {
 
 /**
  * Host Messages
- * @internal
+ * @public
  */
-export declare type HostMessage = UpdateValue | RequestResponse;
+export declare type HostMessage = UpdateValue;
 
 /**
- * 5.2.13
- * IntermediaryVASP
+ * Intermediary VASP
+ * Represents an intermediary Virtual Asset Service Provider
+ * @public
  */
 declare type IntermediaryVASP = {
+    /** The intermediary VASP information */
     intermediaryVASP?: Person;
+    /** The sequence number of this VASP in the transfer path */
     sequence?: number;
 };
 
+/**
+ * Represents an invalid value component message
+ * @public
+ */
 declare type InvalidValue = {
     type: CMType.INVALID;
     value: any;
     errors: ValidationError[];
 };
 
+/**
+ * ISO-3166 Alpha-2 country code
+ * @example "US" for United States, "GB" for United Kingdom
+ * @public
+ */
+declare type ISOCountryCode = string;
+
+/**
+ * 3 letter ISO currency code
+ * @public
+ */
+declare type ISOCurrency = string;
+
+/**
+ * A point in time, represented as a day within the calendar year. Compliant with ISO 8601.
+ * Format: YYYY-MM-DD
+ * @example "2023-05-15" for May 15, 2023
+ * @public
+ */
+declare type ISODate = `${number}-${number}-${number}`;
+
 /**
  * IVMS101 definition
  *
@@ -279,69 +476,99 @@ export declare type IVMS101 = {
 };
 
 /**
- * 5.2.9
- * LegalPerson
+ * Legal Person
+ * Represents a legal person with all associated information
+ * @public
  */
 declare type LegalPerson = {
-    /** The name of the legal person. */
+    /** The name of the legal person */
     name: LegalPersonName;
-    /** The address of the legal person. */
+    /** The address of the legal person */
     geographicAddress?: Address[];
-    /** A distinct identifier that uniquely identifies the person to the institution in context. */
+    /** A distinct identifier that uniquely identifies the person to the institution in context */
     customerNumber?: string;
-    /** A distinct identifier used by governments to uniquely identify a legal person. */
+    /** A distinct identifier used by governments to uniquely identify a legal person */
     nationalIdentification?: NationalIdentification;
-    /** The country in which the legal person is registered. */
-    countryOfRegistration?: string;
+    /** The country in which the legal person is registered */
+    countryOfRegistration?: ISOCountryCode;
 };
 
 /**
- * 5.2.10
- * LegalPersonName
+ * Field names for LegalPerson
+ * @public
+ */
+declare type LegalPersonFieldName = 'name' | 'lei' | 'website' | 'email' | 'phone' | 'geographicAddress' | 'nationalIdentification' | 'countryOfRegistration';
+
+/**
+ * Field properties by field name
+ * @public
+ */
+declare type LegalPersonFields = {
+    [name in LegalPersonFieldName]?: FieldOptions;
+};
+
+/**
+ * Legal Person Name
+ * Represents the full name structure for a legal person
+ * @public
  */
 declare type LegalPersonName = {
+    /** Array of name identifiers */
     nameIdentifier: LegalPersonNameID[];
+    /** Array of local name identifiers */
     localNameIdentifier?: LocalLegalPersonNameID[];
+    /** Array of phonetic name identifiers */
     phoneticNameIdentifier?: LocalLegalPersonNameID[];
 };
 
 /**
- * 5.2.11
- * LegalPersonNameID
+ * Legal Person Name ID
+ * Represents a name identifier for a legal person
+ * @public
  */
 declare type LegalPersonNameID = {
-    /** Name by which the legal person is known. */
+    /** Name by which the legal person is known */
     legalPersonName: string;
-    /** The nature of the name specified. */
+    /** The nature of the name specified */
     legalPersonNameIdentifierType: LegalPersonNameTypeCode;
 };
 
 /**
- * 5.3.9
- * LegalPersonNameTypeCode
- *
- * `LEGL` Legal name - Official name under which an organisation is registered.
- * `SHRT` Short name - Specifies the short name of the organisation.
- * `TRAD` Trading name - Name used by a business for commercial purposes, although its registered legal name, used for contracts and other formal situations, may be another.
+ * Legal Person Name Type Code
+ * Specifies the type of name for a legal person
+ * @public
  */
 declare type LegalPersonNameTypeCode = 'LEGL' | 'SHRT' | 'TRAD';
 
 /**
- * 5.2.12
- * LocalLegalPersonNameID
+ * A LEI Legal Entity Identifier
+ * @public
+ */
+declare type LEI = string;
+
+/**
+ * Local Legal Person Name ID
+ * Represents a local name identifier for a legal person
+ * @public
  */
 declare type LocalLegalPersonNameID = {
+    /** Name of the legal person, maximum 100 characters in local format */
     legalPersonName?: string;
+    /** Type of legal person name identifier */
     legalPersonNameIdentifierType?: LegalPersonNameTypeCode;
 };
 
 /**
- * 5.2.5
- * LocalNaturalPersonNameID
+ * Local Natural Person Name ID
+ * Represents a local name identifier for a natural person
+ * @public
  */
 declare type LocalNaturalPersonNameID = {
+    /** Primary identifier, maximum 100 characters in local format */
     primaryIdentifier?: string;
+    /** Secondary identifier, maximum 100 characters in local format */
     secondaryIdentifier?: string;
+    /** Type of name identifier */
     nameIdentifierType?: NaturalPersonNameTypeCode;
 };
 
@@ -355,97 +582,109 @@ export declare interface MicroTransferProof extends OwnershipProof {
     type: ProofTypes.MicroTransfer;
     txhash: string;
     chain: CAIP2;
-    amount: number;
+    amountSubunits: string;
 }
 
-declare type ModalRequest = {
-    type: CMType.MODAL;
-    url: string;
-    reqid: RequestID;
-};
-
 /**
- * 5.2.8
- * NationalIdentification
+ * National Identification
+ * Represents a national identifier for a person or entity
+ * @public
  */
 declare type NationalIdentification = {
+    /** National identifier (max 35 characters) */
     nationalIdentifier?: string;
+    /** Type of national identifier */
     nationalIdentifierType?: NationalIdentifierTypeCode;
-    countryOfIssue?: string;
+    /** Country that issued the national identifier */
+    countryOfIssue?: ISOCountryCode;
+    /** Registration authority (format: RA followed by 6 digits) */
     registrationAuthority?: string;
 };
 
 /**
- * 5.3.14
- * NationalIdentifierTypeCode
- *
- * `ARNU` Alien registration number - Number assigned by a government agency to identify foreign nationals.
- * `CCPT` Passport number - Number assigned by a passport authority.
- * `RAID` Registration authority identifier - Identifier of a legal entity as maintained by a registration authority.
- * `DRLC` Driver license number - Number assigned to a driver's license.
- * `FIIN` Foreign investment identity number - Number assigned to a foreign investor (other than the alien number).
- * `TXID` Tax identification number - Number assigned by a tax authority to an entity.
- * `SOCS` Social security number - Number assigned by a social security agency.
- * `IDCD` Identity card number - Number assigned by a national authority to an identity card.
- * `LEIX` Legal Entity Identifier - Legal Entity Identifier (LEI) assigned in accordance with ISO 17442 11 .
- * `MISC` Unspecified - A national identifier which may be known but which cannot otherwise be categorized or the category of which the sender is unable to determine.
+ * National Identifier Type Code
+ * Specifies the type of national identifier
+ * @public
  */
 declare type NationalIdentifierTypeCode = 'ARNU' | 'CCPT' | 'RAID' | 'DRLC' | 'FIIN' | 'TXID' | 'SOCS' | 'IDCD' | 'LEIX' | 'MISC';
 
 /**
- * 5.2.2
- * NaturalPerson
+ * Natural Person
+ * Represents a natural person with all associated information
+ * @public
  */
 declare type NaturalPerson = {
-    /** The distinct words used as identification for an individual. */
+    /** The distinct words used as identification for an individual */
     name: NaturalPersonName;
-    /** The particulars of a location at which a person may be communicated with. */
+    /** The particulars of a location at which a person may be communicated with */
     geographicAddress?: Address[];
-    /** A distinct identifier used by governments to uniquely identify a natural person. */
+    /** A distinct identifier used by governments to uniquely identify a natural person */
     nationalIdentification?: NationalIdentification;
-    /** A distinct identifier that uniquely identifies the person to the institution in context. */
+    /** A distinct identifier that uniquely identifies the person to the institution in context */
     customerIdentification?: string;
-    /** Date and place of birth of a person. */
+    /** Date and place of birth of a person */
     dateAndPlaceOfBirth?: DateAndPlaceOfBirth;
-    /** Country in which a person resides (the place of a person's home). */
-    countryOfResidence?: string;
+    /** Country in which a person resides (the place of a person's home) */
+    countryOfResidence?: ISOCountryCode;
 };
 
 /**
- * 5.2.3
- * NaturalPersonName
+ * Field names for NaturalPerson
+ * @public
+ */
+declare type NaturalPersonFieldName = 'name' | 'website' | 'email' | 'phone' | 'geographicAddress' | 'nationalIdentification' | 'dateOfBirth' | 'placeOfBirth' | 'countryOfResidence';
+
+/**
+ * Field properties by field name
+ * @public
+ */
+declare type NaturalPersonFields = {
+    [name in NaturalPersonFieldName]?: FieldOptions;
+};
+
+/**
+ * Natural Person Name
+ * Represents the full name structure for a natural person
+ * @public
  */
 declare type NaturalPersonName = {
+    /** Array of name identifiers */
     nameIdentifier?: NaturalPersonNameID[];
+    /** Array of local name identifiers */
     localNameIdentifier?: LocalNaturalPersonNameID[];
+    /** Array of phonetic name identifiers */
     phoneticNameIdentifier?: LocalNaturalPersonNameID[];
 };
 
 /**
- * 5.2.4
- * NaturalPersonNameID
+ * Natural Person Name ID
+ * Represents a name identifier for a natural person
+ * @public
  */
 declare type NaturalPersonNameID = {
+    /** Primary identifier, maximum 100 characters */
     primaryIdentifier?: string;
+    /** Secondary identifier, maximum 100 characters */
     secondaryIdentifier?: string;
+    /** Type of name identifier */
     nameIdentifierType?: NaturalPersonNameTypeCode;
 };
 
 /**
- * 5.3.8
- * NaturalPersonNameTypeCode
+ * Natural Person Name Type Code
+ * Specifies the type of name for a natural person
  *
- * `ALIA` Alias name  - A name other than the legal name by which a natural person is also known.
- * `BIRT` Name at birth - The name given to a natural person at birth.
- * `MAID` Maiden name - The original name of a natural person who has changed their name after marriage.
- * `LEGL` Legal name - The name that identifies a natural person for legal, official or administrative purposes.
- * `MISC` Unspecified - A name by which a natural person may be known but which cannot otherwise be categorized or the category of which the sender is unable to determine.
+ * @public
  */
 declare type NaturalPersonNameTypeCode = 'ALIA' | 'BIRT' | 'MAID' | 'LEGL' | 'MISC';
 
 /**
  * Primary constructor for Notabene UX elements
  *
+ * This class provides methods to create and manage various Notabene components
+ * such as withdrawal assist, deposit assist, connect, and deposit request.
+ * It also handles URL generation and fragment decoding for these components.
+ *
  * @public
  */
 declare class Notabene {
@@ -454,50 +693,148 @@ declare class Notabene {
     private uxUrl;
     private theme?;
     private locale?;
+    /**
+     * Creates a new instance of the Notabene SDK
+     *
+     * @param config - Configuration options for the Notabene SDK
+     */
     constructor(config: NotabeneConfig);
-    componentUrl(path: string, value: Partial<Transaction>, configuration?: TransactionOptions, callbacks?: CallbackOptions): string;
-    createComponent(path: string, value: Partial<Transaction>, options?: TransactionOptions, callbacks?: CallbackOptions): EmbeddedComponent;
-    createWithdrawalAssist(value: Partial<Withdrawal>, options?: TransactionOptions, callbacks?: CallbackOptions): EmbeddedComponent;
-    createDepositAssist(value: Partial<Deposit>, options?: any, callbacks?: CallbackOptions): EmbeddedComponent;
-    createConnect(value: Partial<Withdrawal>, options?: TransactionOptions, callbacks?: CallbackOptions): EmbeddedComponent;
-    createDepositRequest(value: Partial<DepositRequest>, options?: TransactionOptions, callbacks?: CallbackOptions): EmbeddedComponent;
+    /**
+     * Generates a URL for a Notabene component
+     *
+     * @param path - The path of the component
+     * @param value - Transaction data
+     * @param configuration - Optional transaction configuration
+     * @param callbacks - Optional callback configuration
+     * @returns component URL
+     * @internal
+     */
+    componentUrl<V>(path: string, value: V, configuration?: TransactionOptions, callbacks?: CallbackOptions): string;
+    /**
+     * Creates a new embedded component
+     *
+     * @param path - The path of the component
+     * @param value - Transaction data
+     * @param options - Optional transaction options
+     * @param callbacks - Optional callback configuration
+     * @returns A new EmbeddedComponent instance
+     * @internal
+     */
+    createComponent<V, R>(path: string, value: V, options?: TransactionOptions, callbacks?: CallbackOptions): EmbeddedComponent<V, R>;
+    /**
+     * Creates a withdrawal assist component
+     *
+     * @param value - Withdrawal transaction data
+     * @param options - Optional transaction options
+     * @param callbacks - Optional callback configuration
+     * @returns A new EmbeddedComponent instance for withdrawal assistance
+     */
+    createWithdrawalAssist(value: Partial<Withdrawal>, options?: TransactionOptions, callbacks?: CallbackOptions): EmbeddedComponent<Partial<Withdrawal>, TransactionResponse<Withdrawal>>;
+    /**
+     * Creates a deposit assist component
+     *
+     * @param value - Deposit transaction data
+     * @param options - Optional transaction options
+     * @param callbacks - Optional callback configuration
+     * @returns A new EmbeddedComponent instance for deposit assistance
+     * @alpha
+     */
+    createDepositAssist(value: Partial<Deposit>, options?: any, callbacks?: CallbackOptions): EmbeddedComponent<Partial<Deposit>, TransactionResponse<Deposit>>;
+    /**
+     * Creates a connect component
+     *
+     * @param value - Connection request data
+     * @param options - Optional transaction options
+     * @param callbacks - Optional callback configuration
+     * @returns A new EmbeddedComponent instance for connection
+     */
+    createConnectWallet(value: ConnectionRequest, options?: TransactionOptions, callbacks?: CallbackOptions): EmbeddedComponent<ConnectionRequest, ConnectionResponse>;
+    /**
+     * Creates a deposit request component
+     *
+     * @param value - Deposit request data
+     * @param options - Optional transaction options
+     * @param callbacks - Optional callback configuration
+     * @returns A new EmbeddedComponent instance for deposit requests
+     * @alpha
+     */
+    createDepositRequest(value: DepositRequest, options?: TransactionOptions, callbacks?: CallbackOptions): EmbeddedComponent<DepositRequest, TransactionResponse<DepositRequest>>;
+    /**
+     * Decodes a URL fragment into an object
+     *
+     * @param fragment - The URL fragment to decode
+     * @returns An object containing the decoded key-value pairs
+     */
     decodeFragmentToObject(fragment: string): Record<string, string>;
 }
 export { Notabene }
 export default Notabene;
 
+/**
+ * Notabene Asset Identifier
+ * @public
+ */
 declare type NotabeneAsset = string;
 
+/**
+ * Configuration for the Notabene SDK
+ *
+ * @public
+ */
 /**
  * Configuration for the Notabene SDK
  *
  * @public
  */
 export declare interface NotabeneConfig {
+    /**
+     * The URL of the Notabene API node
+     */
     nodeUrl?: string;
+    /**
+     * The authentication token for the Notabene API
+     */
     authToken?: string;
+    /**
+     * The URL of the Notabene UX components
+     */
     uxUrl?: string;
+    /**
+     * Custom theme configuration for the UX components
+     */
     theme?: Theme;
+    /**
+     * The locale to use for the UX components
+     */
     locale?: string;
 }
 
 /**
- * 6.4
- * The originating VASP is defined in Section 1.1 as the VASP which initiates the VA transfer, and transfers the VA upon receiving the request for a VA transfer on behalf of the originator.
+ * Originating VASP
+ * Represents the VASP which initiates the VA transfer
+ * @public
  */
 declare type OriginatingVASP = {
+    /** The originating VASP information */
     originatingVASP?: Person;
 };
 
 /**
- * 6.2
- * The originator is defined in Section 1.1 as the account holder who allows the VA transfer from that account or, where there is no account, the natural or legal person that places the order with the originating VASP to perform the VA transfer.
+ * Originator
+ * Represents the account holder who initiates the VA transfer
+ * @public
  */
 declare type Originator = {
+    /** Array of persons associated with the originator */
     originatorPersons?: Person[];
+    /** Array of account numbers, maximum 100 characters each */
     accountNumber?: string[];
 };
 
+/**
+ * Fields specific to the originator of a transaction
+ * @public
+ */
 declare type OriginatorFields = {
     source?: Source;
 };
@@ -535,11 +872,14 @@ declare enum PayloadVersionCode {
 }
 
 /**
- * 5.2.1
  * Person
+ * Represents either a natural person or a legal person
+ * @public
  */
 declare type Person = {
+    /** Natural person information */
     naturalPerson?: NaturalPerson;
+    /** Legal person information */
     legalPerson?: LegalPerson;
 };
 
@@ -567,7 +907,7 @@ export declare enum ProofStatus {
 /**
  * The type of Proofs supported
  * @public
- **/
+ */
 export declare enum ProofTypes {
     SelfDeclaration = "self-declaration",
     PersonalSignEIP191 = "eip-191",
@@ -578,28 +918,25 @@ export declare enum ProofTypes {
     Screenshot = "screenshot"
 }
 
+/**
+ * Represents a ready component message
+ * @public
+ */
 declare type Ready = {
     type: CMType.READY;
 };
 
-declare type RequestID = string;
-
-declare type RequestResponse = {
-    type: HMType.REQUEST_RESPONSE;
-    reqid: RequestID;
-};
+declare type RequestID = UUID;
 
+/**
+ * Represents a resize request component message
+ * @public
+ */
 declare type ResizeRequest = {
     type: CMType.RESIZE;
     height: number;
 };
 
-declare type Result = {
-    type: CMType.RESULT;
-    reqid: RequestID;
-    response: TransactionResponse;
-};
-
 /**
  * Ownership Proof using Screenshot
  * @public
@@ -620,6 +957,10 @@ export declare interface SignatureProof extends OwnershipProof {
     wallet_provider: string;
 }
 
+/**
+ * The source of a transaction
+ * @public
+ */
 declare type Source = BlockchainAddress | CAIP10;
 
 /**
@@ -649,21 +990,20 @@ export declare type Theme = {
  * An abstract transaction object
  * @public
  */
-export declare interface Transaction {
+export declare interface Transaction extends ComponentRequest {
     agent: Agent;
-    customer?: Counterparty;
     counterparty: Counterparty;
     asset: TransactionAsset;
     amountDecimal: number;
-    customAssetPrice?: {
+    proof?: OwnershipProof;
+    assetPrice?: {
         price: number;
-        currency: string;
+        currency: ISOCurrency;
     };
 }
 
 /**
  * The asset of a transaction either a Notabene asset, a CAIP-19 asset, or a DTI.
- *
  * @public
  */
 export declare type TransactionAsset = NotabeneAsset | CAIP19 | DTI;
@@ -673,64 +1013,77 @@ export declare type TransactionAsset = NotabeneAsset | CAIP19 | DTI;
  * @public
  */
 export declare interface TransactionOptions {
-    microTransactionAddress?: BlockchainAddress;
-    proofFallbacks?: ProofTypes[];
+    proofs?: {
+        microTransfer?: {
+            destination: BlockchainAddress;
+            amountSubunits: string;
+            timeout?: number;
+        };
+        fallbacks?: ProofTypes[];
+    };
+    allowedAgentTypes?: AgentType[];
+    allowedCounterpartyTypes?: PersonType[];
+    fields?: FieldTypes;
 }
 
 /**
  * The response of a transaction
  * @public
  */
-export declare type TransactionResponse = {
-    value: Transaction;
+export declare interface TransactionResponse<V> extends ComponentResponse {
+    value: V;
     ivms: IVMS101;
     proof?: OwnershipProof;
-    valid: boolean;
-    status: Status;
-    errors: ValidationError[];
     txCreate?: V1Transaction;
-};
+}
 
 /**
- * 6.6
- * The transfer path refers to the intermediary VASP(s) participating in a serial chain that receive(s) and retransmit(s) a VA transfer on behalf of the originating VASP and the beneficiary VASP, or another intermediary VASP, together with their corresponding sequence number.
+ * Transfer Path
+ * Represents the path of intermediary VASPs in a transfer
+ * @public
  */
 declare type TransferPath = {
+    /** Array of intermediary VASPs involved in the transfer */
     transferPath?: IntermediaryVASP[];
 };
 
 /**
- * 5.3.16
- * TransliterationMethodCode
- *
- * `arab` Arabic (Arabic language) - ISO 233-2:1993
- * `aran` Arabic (Persian language) - ISO 233-3:1999
- * `armn` Armenian - ISO 9985:1996
- * `cyrl` Cyrillic - ISO 9:1995
- * `deva` Devanagari & related Indic - ISO 15919:2001
- * `geor` Georgian - ISO 9984:1996
- * `grek` Greek - ISO 843:1997
- * `hani` Han (Hanzi, Kanji, Hanja) - ISO 7098:2015
- * `hebr` Hebrew - ISO 259-2:1994
- * `kana` Kana - ISO 3602:1989
- * `kore` Korean - Revised Romanization of Korean
- * `thai` Thai - ISO 11940-2:2007
- * `othr` Script other than those listed above - Unspecified
+ * Transliteration Method Code
+ * Specifies the method used to transliterate text
+ * @public
  */
 declare type TransliterationMethodCode = 'arab' | 'aran' | 'armn' | 'cyrl' | 'deva' | 'geor' | 'grek' | 'hani' | 'hebr' | 'kana' | 'kore' | 'thai' | 'othr';
 
+/**
+ * A travel address
+ * @public
+ */
 declare type TravelAddress = `ta${string}`;
 
+/**
+ * Represents an update value host message
+ * @public
+ */
 declare type UpdateValue = {
     type: HMType.UPDATE;
-    value: Partial<Transaction>;
+    value: ComponentRequest;
 };
 
+/**
+ * A Uniform Resource Identifier
+ * @public
+ */
 declare type URI = string;
 
-declare type V1Asset = {
+/**
+ * UUID v4
+ * @public
+ */
+declare type UUID = string;
+
+declare type V1Asset = NotabeneAsset | {
     caip19: CAIP19;
-} | string;
+};
 
 /**
  * Transaction payload suitable for calling Notabene v1 tx/create
@@ -747,6 +1100,10 @@ declare type V1Transaction = {
     beneficiary: Beneficiary;
 };
 
+/**
+ * Validation error
+ * @public
+ */
 declare type ValidationError = {
     attribute: string;
     message: string;
@@ -757,8 +1114,10 @@ declare type ValidationError = {
  * @public
  */
 export declare interface VASP extends Agent {
-    url?: string;
-    name?: string;
+    lei?: LEI;
+    logo?: URI;
+    website?: URI;
+    countryOfRegistration?: ISOCountryCode;
 }
 
 /**