@notabene/javascript-sdk 2.0.0-next.9 → 2.0.0

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,136 @@ 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;
+    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;
 };
 
-declare type BlockchainAddress = string;
+/**
+ * A blockchain address
+ * @public
+ */
+/**
+ * A native blockchain address string
+ *
+ * @remarks
+ * Represents a blockchain address in the native format specific to a particular chain.
+ * This could be an Ethereum address, Bitcoin address, or other chain-specific format.
+ * The address format and validation rules depend on the underlying blockchain.
+ *
+ * @example "0x742d35Cc6634C0532925a3b844Bc454e4438f44e" // Ethereum address
+ * @example "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa" // Bitcoin address
+ * @example "cosmos1t2uflqwqe0fsj0shcfkrvpukewcw40yjj6hdc0" // Cosmos address
+ * @public
+ */
+export declare type BlockchainAddress = string;
 
-declare type CAIP10 = `${CAIP2}:${string}`;
+/**
+ * Chain Agnostic Account Identifier (CAIP-10)
+ * Represents an account/address on a specific blockchain following the CAIP-10 specification.
+ * Extends CAIP-2 by adding the account address specific to that chain.
+ *
+ * Format: `{caip2}:{address}`
+ * - caip2: The CAIP-2 chain identifier (e.g. 'eip155:1')
+ * - address: Chain-specific account address format
+ *
+ * @example "eip155:1:0x742d35Cc6634C0532925a3b844Bc454e4438f44e" // Ethereum account on mainnet
+ * @example "bip122:000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f:128Lkh3S7CkDTBZ8W7BbpsN3YYizJMp8p6" // Bitcoin account on mainnet
+ * @example "cosmos:cosmoshub-3:cosmos1t2uflqwqe0fsj0shcfkrvpukewcw40yjj6hdc0" // Cosmos account
+ * @see {@link https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-10.md | CAIP-10 Specification}
+ * @public
+ */
+export declare type CAIP10 = `${CAIP2}:${string}`;
 
-declare type CAIP19 = `${CAIP2}/${string}:${string}`;
+/**
+ * Chain Agnostic Asset Identifier (CAIP-19)
+ * Represents an asset/token on a specific blockchain following the CAIP-19 specification.
+ * Extends CAIP-2 by adding asset type and identifier information.
+ *
+ * Format: `{caip2}/{asset_namespace}:{asset_reference}`
+ * - caip2: The CAIP-2 chain identifier (e.g. 'eip155:1')
+ * - asset_namespace: The asset standard (e.g. 'erc20', 'erc721', 'slip44')
+ * - asset_reference: Chain/standard-specific asset identifier
+ *
+ * @example "eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f" // DAI token on Ethereum mainnet
+ * @example "eip155:1/erc721:0x06012c8cf97BEaD5deAe237070F9587f8E7A266d" // CryptoKitties NFT contract
+ * @example "cosmos:cosmoshub-3/slip44:118" // ATOM token on Cosmos Hub
+ * @see {@link https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-19.md | CAIP-19 Specification}
+ * @public
+ */
+export declare type CAIP19 = `${CAIP2}/${string}:${string}`;
 
-declare type CAIP2 = `${string}:${string}`;
+/**
+ * Chain Agnostic Blockchain Identifier (CAIP-2)
+ * Represents a blockchain in a chain-agnostic way following the CAIP-2 specification.
+ * The identifier consists of a namespace and reference separated by a colon.
+ *
+ * Format: `namespace:reference`
+ * - namespace: Represents the blockchain namespace (e.g. 'eip155', 'bip122', 'cosmos')
+ * - reference: Chain-specific identifier within that namespace
+ *
+ * @example "eip155:1" // Ethereum Mainnet
+ * @example "bip122:000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f" // Bitcoin Mainnet
+ * @example "cosmos:cosmoshub-3" // Cosmos Hub Mainnet
+ * @see {@link https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md | CAIP-2 Specification}
+ * @public
+ */
+export declare type CAIP2 = `${string}:${string}`;
 
-declare interface CallbackOptions {
+/**
+ * Options for callback and redirect URIs
+ * @public
+ */
+export declare interface CallbackOptions {
     callback?: URI;
     redirectUri?: URI;
 }
 
-declare type Cancel = {
+/**
+ * Represents a cancel component message
+ * @internal
+ */
+export declare type Cancel = {
     type: CMType.CANCEL;
 };
 
-declare type CloseModal = {
-    type: CMType.CLOSE;
-    reqid: RequestID;
-};
-
 /**
- * Component Message Types
- * @internal
+ * Component Message Type enum representing different message types that can be sent
+ * between the host and component.
+ *
+ * @remarks
+ * - COMPLETE: Indicates a completed operation with response data
+ * - RESIZE: Request to adjust component size/dimensions
+ * - RESULT: Operation result notification
+ * - READY: Component is initialized and ready
+ * - INVALID: Validation failed with errors
+ * - ERROR: Operation encountered an error
+ * - CANCEL: Operation was cancelled
+ * @public
  */
 export declare const enum CMType {
     COMPLETE = "complete",
@@ -122,44 +205,160 @@ export declare const enum CMType {
     RESULT = "result",
     READY = "ready",
     INVALID = "invalid",
-    MODAL = "openModal",
     ERROR = "error",
-    CLOSE = "closeModal",
     CANCEL = "cancel"
 }
 
-declare type Completed = {
+/**
+ * Represents a completed component message
+ * @typeParam T - The overall Value type being returned
+ * @param response - The Response object which wraps T
+ * @public
+ */
+export declare type Completed<T> = {
     type: CMType.COMPLETE;
-    response: TransactionResponse;
+    response: TransactionResponse<T>;
 };
 
 /**
- * Component Message
- * @internal
+ * Union type representing all possible messages that can be sent from a component
+ *
+ * @remarks
+ * Components communicate their state and results back to the host application
+ * through these message types:
+ * - Completed: Operation finished successfully with response data
+ * - Cancel: User cancelled the operation
+ * - Error: Operation failed with error message
+ * - Ready: Component initialized and ready for use
+ * - ResizeRequest: Component needs to adjust its dimensions
+ * - InvalidValue: Validation failed with current partial value
+ *
+ * @typeParam T - The value type that will be returned in Completed messages
+ *
+ * @see {@link Completed} For successful completion message format
+ * @see {@link Cancel} For cancellation message format
+ * @see {@link Error} For error message format
+ * @see {@link Ready} For ready message format
+ * @see {@link ResizeRequest} For resize message format
+ * @see {@link InvalidValue} For validation failure message format
+ * @public
+ */
+export declare type ComponentMessage<T> = Completed<T> | Cancel | Error_2 | Ready | ResizeRequest | InvalidValue<T>;
+
+/**
+ * Base interface for requests sent to SDK components
+ *
+ * @remarks
+ * Defines core properties that all component requests share:
+ * - Optional unique request ID for tracking/correlating requests and responses
+ * - Optional customer detailsfor pre-filling component data
+ *
+ * This interface is extended by specific request types like:
+ * - Transaction requests for sending/receiving assets
+ * - Connection requests for establishing VASP to VASP communication
+ *
+ * @see {@link Transaction} For transaction-specific request properties
+ * @see {@link ConnectionRequest} For connection-specific request properties
+ * @public
+ */
+declare interface ComponentRequest {
+    requestId?: RequestID;
+    customer?: Counterparty;
+}
+
+/**
+ * Base response interface for all SDK component operations
+ *
+ * @remarks
+ * Provides standardized response propertiesfor component interactions:
+ * - requestID: Links response back to the originating request
+ * - valid: Boolean indicating if the operation was valid/successful
+ * - status: Current verification status of the operation
+ * - errors: Array of validation errors if any occurred
+ *
+ * This interface is extended by specific response types like:
+ * - TransResponse for transaction operations
+ * - ConnectionResponse for VASP connection operations
+ *
+ * @see {@link Status} For possible status values
+ * @see {@link ValidationError} For error structure
+ * @see {@link TransactionResponse} For transaction-specific responses
+ * @public
+ */
+export declare interface ComponentResponse {
+    requestID: RequestID;
+    valid: boolean;
+    status: Status;
+    errors: ValidationError[];
+}
+
+/**
+ * An object representing options for a Connection Request
+ * @public
+ */
+declare type ConnectionOptions = Omit<TransactionOptions, 'allowedAgentTypes' | 'allowedCounterpartyTypes' | 'vasps' | 'fields' | 'hide'>;
+
+/**
+ * An object representing a connection request
+ * @public
  */
-export declare type ComponentMessage = Completed | Cancel | Error_2 | Result | Ready | ResizeRequest | ModalRequest | InvalidValue | CloseModal;
+export declare interface ConnectionRequest extends ComponentRequest {
+    asset: TransactionAsset;
+}
 
 /**
  * The counterparty of a transaction.
  * @public
  */
+/**
+ * Interface representing a party involved in a transaction other than the initiator
+ *
+ * @remarks
+ fines the core properties that identify and describe a counterparty:
+ * - name: The display or legal name of the counterparty
+ * - accountNumber: An account identifier/reference number
+ * - did: Decentralized identifier for the counterparty
+ * - type: Classification as natural person, legal entity, or self
+ * - verified: Whether the counterparty's identity has been verified
+ * - geographicAddress: Physical/mailing address information
+ * - nationalIdentification: Government-issued ID details
+ * - website: Official web presence
+ * - phone: Contact phone number
+ * - email: Contact email address
+ *
+ * This interface serves as the base for more specific counterparty types:
+ * @see {@link NaturalPerson} For individual person properties
+ * @see {@link LegalPerson} For organization/entity properties
+ *
+ * @public
+ */
 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;
+    email?: string;
 }
 
-declare type CryptoCredential = `${string}.${string}.mastercard`;
+/**
+ * A crypto credential
+ * @public
+ */ export 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;
 };
 
@@ -173,6 +372,15 @@ export declare interface DeclarationProof extends OwnershipProof {
     confirmed: boolean;
 }
 
+/**
+ * Decodes a URL fragment into an object
+ *
+ * @param fragment - The URL fragment to decode
+ * @returns An object containing the decoded key-value pairs
+ * @public
+ */
+export declare function decodeFragmentToObject(fragment: string): Record<string, string>;
+
 /**
  * An object representing a deposit transaction
  * @public
@@ -184,86 +392,251 @@ export declare interface Deposit extends OriginatorFields, Transaction {
  * An object representing a request for a deposit
  * @public
  */
-export declare interface DepositRequest extends DepositRequestFields, Transaction {
+export declare interface DepositRequest extends DepositRequestFields, ComponentRequest {
 }
 
+/**
+ * Fields specific to a deposit request
+ * @public
+ */
 declare type DepositRequestFields = {
-    destinations: destination[];
+    destination: BlockchainAddress | CAIP10;
+    asset: TransactionAsset;
+    amountDecimal?: number;
+    travelAddress?: TravelAddress;
+    cryptoCredential?: CryptoCredential;
 };
 
+/**
+ * An object representing options for a Deposit Request
+ * @public
+ */
+declare interface DepositRequestOptions {
+    showQrCode?: boolean;
+}
+
 /**
  * The destination of a transaction either a blockchain address, a CAIP-19 address, or a travel address.
  * @public
  */
-export declare type destination = BlockchainAddress | CAIP10 | CryptoCredential | TravelAddress;
+export declare type Destination = BlockchainAddress | CAIP10 | CryptoCredential | TravelAddress;
 
-declare type DID = `did:${string}:${string}`;
+/**
+ * A Decentralized Identifier
+ * @public
+ */
+export declare type DID = `did:${string}:${string}`;
 
-declare type DTI = string;
+/**
+ * Digital Token Identifier (DTI) following ISO 24165 standard
+ *
+ * @remarks
+ * A standardized identifier for digital assets and cryptocurrencies. The DTI system
+ * provides unique and unambiguous identification of digital tokens, supporting interoperability
+ * and clarity in financial markets.
+ *
+ * Format: `DTI[NNNNN]` where N is a digit
+ *
+ * @example "DTI00001" // Example DTI for Bitcoin
+ * @example "DTI00002" // Example DTI for Ethereum
+ *
+ * @see {@link https://dtif.org/ | Digital Token Identifier Foundation}
+ * @see {@link https://www.iso.org/standard/77895.html | ISO 24165}
+ * @public
+ */
+export declare type DTI = string;
 
 /**
  * An embedded Notabene component
  * @public
  */
-export declare class EmbeddedComponent {
+export declare class EmbeddedComponent<V, O> {
     private _url;
     private _value;
+    private _options?;
     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: Partial<V>, options?: O);
+    /**
+     * 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(): Partial<V>;
+    get options(): O | undefined;
     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;
-    embed(parent: Element): void;
-    send(message: HostMessage): void;
-    on(messageType: string, callback: MessageCallback): void;
-    off(messageType: string, callback: MessageCallback): void;
-    update(value: Partial<Transaction>): void;
-    completion(): Promise<TransactionResponse>;
-    openModal(): void;
-    private closeModal;
+    /**
+     * Embeds the component into a parent element
+     * @param parent - The parent element to embed the component into
+     */
+    embed(parent: Element, modal?: boolean): void;
+    removeEmbed(): void;
+    /**
+     * Sends a message to the embedded component
+     * @param message - The message to send
+     */
+    send(message: HostMessage<V, O>): 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<V>): () => 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<V>): void;
+    /**
+     * Updates the transaction value and sends an update message to the component
+     * @param value - The new transaction value
+     */
+    update(value: Partial<V>, options?: O): void;
+    /**
+     * Waits for the component to complete and returns the transaction response
+     * @returns A promise that resolves with the transaction response
+     */
+    completion(): Promise<TransactionResponse<V>>;
+    /**
+     * Opens the component in a modal dialog
+     */
+    openModal(): Promise<TransactionResponse<V>>;
+    /**
+     * Closes the modal dialog
+     *
+     */
+    closeModal(): void;
 }
 
+/**
+ * Represents an error component message
+ * @param message - Error message
+ * @public
+ */
 declare type Error_2 = {
     type: CMType.ERROR;
     message: string;
 };
+export { Error_2 as Error }
 
 /**
- * Host Message Types
- * @internal
+ * Field properties
+ * @public
  */
-declare const enum HMType {
+declare type FieldOptions = boolean | {
+    optional: boolean;
+    transmit: boolean;
+};
+
+/**
+ * Field type configuration
+ * @public
+ */
+export declare type FieldTypes = {
+    naturalPerson?: NaturalPersonFields;
+    legalPerson?: LegalPersonFields;
+};
+
+/**
+ * Host Message Type enum representing different message types that can be sent
+ * from the host application.
+ *
+ * @remarks
+ * - UPDATE: Message to update component value/state
+ * - REQUEST_RESPONSE: Message requesting a response from component
+ * @public
+ */
+export declare const enum HMType {
     UPDATE = "update",
     REQUEST_RESPONSE = "requestResponse"
 }
 
 /**
- * Host Messages
- * @internal
+ * Union type representing all possible messages that can be sent from the host application
+ * to a component
+ *
+ * @remarks
+ * Currently only supports update messages which allow the host to modify component
+ * and configuration. The host uses these messages to communicate changes to the component
+ * without requiring full reinitialization.
+ *
+ * @typeParam T - The value type that components operate on
+ * @typeParam O - The options type used to configure component behavior
+ *
+ * @see {@link UpdateValue} For the structure of update messages
+ * @see {@link HMType} For message type constants
+ * @public
  */
-export declare type HostMessage = UpdateValue | RequestResponse;
+export declare type HostMessage<T, O> = UpdateValue<T, O>;
 
 /**
- * 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;
 };
 
-declare type InvalidValue = {
+/**
+ * Represents an invalid value component message
+ * @typeParam T - The overall Value type being returned
+ * @param value - The current Partial value
+ * @param errors - Array of validation errors
+ * @internal
+ */
+export declare type InvalidValue<T> = {
     type: CMType.INVALID;
-    value: any;
+    value: Partial<T>;
     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,73 +652,134 @@ export declare type IVMS101 = {
 };
 
 /**
- * 5.2.9
- * LegalPerson
+ * Interface representing a legal entity (organization/company) involved in a transaction
+ *
+ * @remarks
+ * Extends the baseface to add properties specific to legal entities:
+ * - type: MustPersonType.LEGAL to identify as an organization
+ * - name: Required registered legal name of the entity
+ * - lei: Optional Legal Entity Identifier for regulated entities
+ * - logo: Optional URI to the organization's logo image
+ * - countryOfRegistration: Optional ISO country code where entity is registered
+ *
+ * This interface captures the additional identifying information required for
+ * legal persons under FATF Travel Rule requirements. The properties align with
+ * standard business KYC (Know Your Businessta collection practices.
+ *
+ * @see {@link Counterparty} For base properties common to all counterparties
+ * @see {@link PersonType} For person type classification
+ * @see {@link LEI} For Legal Entity Identifier format
+ * @public
+ */
+export declare interface LegalPerson extends Counterparty {
+    type: PersonType.LEGAL;
+    name: string;
+    lei?: LEI;
+    logo?: URI;
+    countryOfRegistration?: ISOCountryCode;
+}
+
+/**
+ * Legal Person
+ * Represents a legal person with all associated information
+ * @public
  */
-declare type LegalPerson = {
-    /** The name of the legal person. */
+declare type LegalPerson_2 = {
+    /** 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;
+};
+
+declare type LegalPersonFieldName = 'name' | 'lei' | 'website' | 'email' | 'phone' | 'geographicAddress' | 'nationalIdentification' | 'countryOfRegistration';
+
+/**
+ * Field properties by field name
+ * @public
+ */
+declare type LegalPersonFields = {
+    [name in LegalPersonFieldName]?: FieldOptions;
 };
 
 /**
- * 5.2.10
- * LegalPersonName
+ * 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
+ */
+export 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;
 };
 
-declare type MessageCallback = (message: ComponentMessage) => void;
+/**
+ * Callback function for handling component messages.
+ *
+ * @typeParam T - The type of data contained in the component message
+ * @param message - The message object containing the component data and type
+ * @public
+ */
+export declare type MessageCallback<T> = (message: ComponentMessage<T>) => void;
 
 /**
  * Ownership Proof using Micro Transfer
@@ -353,99 +787,140 @@ declare type MessageCallback = (message: ComponentMessage) => void;
  */
 export declare interface MicroTransferProof extends OwnershipProof {
     type: ProofTypes.MicroTransfer;
-    txhash: string;
+    proof: string;
     chain: CAIP2;
-    amount: number;
+    asset: CAIP19;
+    destination: BlockchainAddress;
+    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 = {
+export 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
+ * Interface representing a natural person (individual) involved in a transaction
+ *
+ * @remarks
+ * Extends the baseinterface to add properties specific to individual persons:
+ * - type: Must be PersonType.NATURAL to identify as an individual
+ * - dateOfBirth: Optional ISO format birth date for identity verification
+ * - placeOfBirth: Optional birth place for identity verification
+ * - countryOfResidence: Optional ISO country code of current residence
+ * - name: Required full legal name of the individual
+ *
+ * This interface captures the additional identifying information required for
+ * natural persons under FATF Travel Rule requirements. The properties align
+ * with standard KYC (Know Your Customer) data collection practices.
+ *
+ * @see {@link Counterparty} For base properties common to all counterparties
+ * @see {@link PersonType} For person type classification
+ * @public
+ */
+export declare interface NaturalPerson extends Counterparty {
+    type: PersonType.NATURAL;
+    dateOfBirth?: ISODate;
+    placeOfBirth?: string;
+    countryOfResidence?: ISOCountryCode;
+    name: string;
+}
+
+/**
+ * Natural Person
+ * Represents a natural person with all associated information
+ * @public
  */
-declare type NaturalPerson = {
-    /** The distinct words used as identification for an individual. */
+declare type NaturalPerson_2 = {
+    /** 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 for Natural persons
+ * @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,19 +929,85 @@ 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;
-    decodeFragmentToObject(fragment: string): Record<string, string>;
-}
-export { Notabene }
+    /**
+     * 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, O>(path: string, value: V, configuration?: O, 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, O>(path: string, value: Partial<V>, options?: O, callbacks?: CallbackOptions): EmbeddedComponent<V, O>;
+    /**
+     * 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<Withdrawal, TransactionOptions>;
+    /**
+     * 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
+     * @alpha
+     */
+    createConnectWallet(value: ConnectionRequest, options?: ConnectionOptions, callbacks?: CallbackOptions): EmbeddedComponent<ConnectionRequest, ConnectionOptions>;
+    /**
+     * 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
+     * @public
+     */
+    createDepositRequest(value: DepositRequest, options?: DepositRequestOptions, callbacks?: CallbackOptions): EmbeddedComponent<DepositRequest, DepositRequestOptions>;
+}
 export default Notabene;
 
-declare type NotabeneAsset = string;
+/**
+ * Notabene Asset Identifier
+ * @public
+ */
+/**
+ * Internal identifier for assets in the Notabene system
+ *
+ * @remarks
+ * A standardized string format used within Notabene to identify cryptocurrencies,
+ * tokens, and other digital assets. This is Notabene's legacy asset identification
+ * system that may be used alongside CAIP-19 and DTI identifiers.
+ *
+ * @example "ETH_USDT" // USDT token on Ethereum
+ * @example "BTC" // Bitcoin
+ * @see {@link CAIP19} For chain-agnostic asset identifiers
+ * @see {@link DTI} For ISO standardized identifiers
+ * @public
+ */
+export declare type NotabeneAsset = string;
 
 /**
  * Configuration for the Notabene SDK
@@ -474,36 +1015,77 @@ declare type NotabeneAsset = string;
  * @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;
 };
 
 /**
- * Ownership Proof
+ * Base interface for proving ownership of an account or address
+ *
+ * @remarks
+ * TheOwnershipProof interface provides a common structure for different types of ownership verification:
+ * - All proofs must specify their type from the supported ProofTypes enum
+ * - Current verification status is tracked via ProofStatus
+ * - Links the proof to a decentralized identifier (DID)
+ * - Specifies the blockchain account/address being proven using CAIP-10 format
+ *
+ * This interface is extended by specific proof types like:
+ * - SignatureProof for cryptographic signatures
+ * - DeclarationProof for self-declarations
+ * - MicroTransferProof for transaction-based proof
+ * - ScreenshotProof for image-based verification
+ *
+ * @see {@link ProofTypes} For supported proof methods
+ * @see {@link ProofStatus} For possible verification states
+ * @see {@link CAIP10} For address format specification
  * @public
  */
 export declare interface OwnershipProof {
@@ -535,18 +1117,38 @@ declare enum PayloadVersionCode {
 }
 
 /**
- * 5.2.1
  * Person
+ * Represents either a natural person or a legal person
+ * @public
  */
 declare type Person = {
-    naturalPerson?: NaturalPerson;
-    legalPerson?: LegalPerson;
+    /** Natural person information */
+    naturalPerson?: NaturalPerson_2;
+    /** Legal person information */
+    legalPerson?: LegalPerson_2;
 };
 
 /**
  * The type of counterparty. Either a natural person or a legal person. If the customer is the same as the counterparty then the counterparty is a self.
  * @public
  */
+/**
+ * Enum defining the types of persons/entities in a transaction
+ *
+ * @remarks
+ * This classification system aligns with FATF travel rule requirements and defines:
+ * - NATURAL: Individual human persons acting in their own capacity
+ * - LEGAL: Registered organizations, companies, or other legal entities
+ * - SELF: When the counterparty is the same as the customer (first party transaction)
+ *
+ * The type affects what information must be collected and transmitted as part of
+ * travel rule compliance. Different verification and due diligence requirements
+ * apply to each type.
+ *
+ * @see {@link NaturalPerson} For natural person data requirements
+ * @see {@link LegalPerson} For legal person data requirements
+ * @public
+ */
 export declare enum PersonType {
     NATURAL = "natural",
     LEGAL = "legal",
@@ -554,7 +1156,15 @@ export declare enum PersonType {
 }
 
 /**
- * Status of the proof
+ * Status of the ownership proof verification process
+ *
+ * @remarks
+ * Represents the different states that an ownership proof can be in during and after verification:
+ * - PENDING: Initial state where verification is in progress or awaiting processing
+ * - FAILED: The proof was rejected due to failing verification checks
+ * - FLAGGED: The proof requires manual review due to suspicious or unclear verification results
+ * - VERIFIED: The proof has passed all verification checks successfully
+ *
  * @public
  */
 export declare enum ProofStatus {
@@ -565,41 +1175,59 @@ export declare enum ProofStatus {
 }
 
 /**
- * The type of Proofs supported
+ * Types of ownership proofs supported by the system
+ *
+ * @remarks
+ * Supported proof types:
+ * - SelfDeclaration: User self-declares ownership without cryptographic proof
+ * - EIP191: Ethereum personal signature following EIP-191 standard
+ * - SIWE: Sign-In with Ethereum message signature (EIP-4361)
+ * - EIP712: Ethereum typed data signature following EIP-712 standard
+ * - BIP137: Bitcoin message signature following BIP-137
+ * - XPUB: Extended public key signature for HD wallets
+ * - MicroTransfer: Proof via small blockchain transaction
+ * - Screenshot: Image proof of ownership/access
+ *
+ * @see {@link SignatureProof} For signature-based proofs
+ * @see {@link DeclarationProof} For self-declaration proofs
+ * @see {@link MicroTransferProof} For transaction-based proofs
+ * @see {@link ScreenshotProof} For screenshot proofs
  * @public
- **/
+ */
 export declare enum ProofTypes {
     SelfDeclaration = "self-declaration",
-    PersonalSignEIP191 = "eip-191",
-    PersonalSignEIP712 = "eip-712",
-    PersonalSignBIP137 = "bip-137",
-    PersonalSignXPUB = "xpub",
+    SIWE = "siwe",
+    SIWX = "siwx",
+    EIP191 = "eip-191",
+    EIP712 = "eip-712",
+    EIP1271 = "eip-1271",
+    BIP137 = "bip-137",
+    BIP137_XPUB = "xpub",
+    ED25519 = "ed25519",
     MicroTransfer = "microtransfer",
-    Screenshot = "screenshot"
+    Screenshot = "screenshot",
+    Connect = "connect"
 }
 
-declare type Ready = {
+/**
+ * Represents a ready component message
+ * @public
+ */
+export declare type Ready = {
     type: CMType.READY;
 };
 
-declare type RequestID = string;
-
-declare type RequestResponse = {
-    type: HMType.REQUEST_RESPONSE;
-    reqid: RequestID;
-};
+declare type RequestID = UUID;
 
-declare type ResizeRequest = {
+/**
+ * Represents a resize request component message. This is handled by the library.
+ * @internal
+ */
+export declare type ResizeRequest = {
     type: CMType.RESIZE;
     height: number;
 };
 
-declare type Result = {
-    type: CMType.RESULT;
-    reqid: RequestID;
-    response: TransactionResponse;
-};
-
 /**
  * Ownership Proof using Screenshot
  * @public
@@ -610,16 +1238,33 @@ export declare interface ScreenshotProof extends OwnershipProof {
 }
 
 /**
- * Ownership Proof using Message Signature
+ * Interface for signature-based ownership proofs that use cryptographic message signing
+ *
+ * @remarks
+ * Extends the base OwnershipProface to add signature-specific properties:
+ * - Supports multiple signature standards like EIP-191, EIP-712, BIP-137, SIWE
+ * - Includes the cryptographic proof signature string
+ * - Contains an attestation message that was signed
+ * - Records which wallet provider was used for signing
+ *
+ * The signature proves ownership by demonstrating control of the private keys
+ * associated with the claimed address.
+ *
+ * @see {@link ProofTypes} For supported signature types
+ * @see {@link OwnershipProof} For base proof properties
  * @public
  */
 export declare interface SignatureProof extends OwnershipProof {
-    type: ProofTypes.PersonalSignEIP191 | ProofTypes.PersonalSignEIP712 | ProofTypes.PersonalSignBIP137 | ProofTypes.PersonalSignXPUB;
+    type: ProofTypes.EIP191 | ProofTypes.EIP712 | ProofTypes.EIP1271 | ProofTypes.BIP137 | ProofTypes.BIP137_XPUB | ProofTypes.ED25519 | ProofTypes.SIWX | ProofTypes.SIWE;
     proof: string;
     attestation: string;
     wallet_provider: string;
 }
 
+/**
+ * The source of a transaction
+ * @public
+ */
 declare type Source = BlockchainAddress | CAIP10;
 
 /**
@@ -646,24 +1291,59 @@ export declare type Theme = {
 };
 
 /**
- * An abstract transaction object
+ * Specify what to do under the provided threshold.
+ *
+ * Eg. to allow self-declaration for all transactions under 1000 EUR
+ *
+ * Note to support threshold you MUST include the Asset Price in the Transaction
+ *
+ * @see {@link Transaction} Transaction object
+ *
  * @public
  */
-export declare interface Transaction {
+export declare interface ThresholdOptions {
+    threshold: number;
+    currency: ISOCurrency;
+    proofTypes?: ProofTypes[];
+}
+
+/**
+ * Core transaction interface representing a crypto asset transfer between parties
+ *
+ * @remarks
+ * Extends ComponentRequest to add transaction-specific properties:
+ * - agent: The entity facilitating/executing the transaction
+ * - counterparty: The other party involved in the transaction
+ * - asset: The cryptocurrency or token being transferred
+ * - amountDecimal: The amount to transfer in decimal format
+ * - proof: Optional ownership proof verifying control of involved addresses
+ * - assetPrice: Optional price information in a fiat currency
+ *
+ * This interface serves as the base for specific transaction types like:
+ * - Withdrawals for sending assets out
+ * - Deposits for receiving assets
+ * - Deposit requests for requesting asset transfers
+ *
+ * @see {@link Withdrawal} For withdrawal-specific transaction properties
+ * @see {@link Deposit} For deposit-specific transaction properties
+ * @see {@link Agent} For agent details
+ * @see {@link Counterparty} For counterparty information
+ * @public
+ */
+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,94 +1353,199 @@ 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[];
+        deminimis?: ThresholdOptions;
+    };
+    allowedAgentTypes?: AgentType[];
+    allowedCounterpartyTypes?: PersonType[];
+    fields?: FieldTypes;
+    vasps?: VASPOptions;
+    hide?: ValidationSections[];
 }
 
 /**
- * The response of a transaction
+ * Response interface for transaction-related operations
+ *
+ * @remarks
+ * Extends ComponentResponse to add transaction-specific response data:
+ * - value: The resulting transaction value of generic type V
+ * - ivms101: IVMS 101 travel rule data for the transaction
+ * - proof: Optional ownership proof details if required
+ * - txCreate: Optional V1 transaction payload for legacy API compatibility
+ *
+ * @typeParam V - Type of the transaction value being returned
+ *
+ * @see {@link ComponentResponse} For base response properties
+ * @see {@link IVMS101} For travel rule data structure
+ * @see {@link OwnershipProof} For proof details
+ * @see {@link V1Transaction} For legacy transaction format
  * @public
  */
-export declare type TransactionResponse = {
-    value: Transaction;
-    ivms: IVMS101;
+export declare interface TransactionResponse<V> extends ComponentResponse {
+    value: V;
+    ivms101: 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';
 
-declare type TravelAddress = `ta${string}`;
+/**
+ * A travel address
+ * @public
 
-declare type UpdateValue = {
+ * A standardized travel rule address format
+ *
+ * @remarks
+ * Represents a special address format used for travel rule compliance. Travel addresses
+ * are prefixed with 'ta' and contain encoded information about the transaction
+ * and counterparty details required for travel rule reporting.
+ *
+ * The format ensures consistent handling of travel rule data across different
+ * VASPs and blockchain networks while maintaining privacy.
+ *
+ * @example "ta1234abcd..." // Example travel rule address
+ * @see {@link BlockchainAddress} For native chain addresses
+ * @see {@link CAIP10} For chain-agnostic addresses
+
+ */ export declare type TravelAddress = `ta${string}`;
+
+/**
+ * Message type for updating component state and configuration from host application
+ *
+ * @remarks
+ * Defines the structure of update messages sent from host to component:
+ * - type: Identifies this as an update message
+ * - value: New partial state/data to update the component with
+ * - options: Optional configuration parameters to modify component behavior
+ *
+ * The host can use this to dynamically update both the component's data
+ * and its configuration without requiring a full reload/reinitialize.
+ *
+ * @typeParam T - The type of the value being updated
+ * @typeParam O - The type of the optional configuration parameters
+ *
+ * @see {@link HMType} For message type constants
+ * @see {@link HostMessage} For full host message type union
+ * @public
+ */
+export declare type UpdateValue<T, O> = {
     type: HMType.UPDATE;
-    value: Partial<Transaction>;
+    value: Partial<T>;
+    options?: O;
 };
 
+/**
+ * A Uniform Resource Identifier
+ * @public
+ */
 declare type URI = string;
 
-declare type V1Asset = {
+/**
+ * UUID v4 string identifier
+ * A universally unique identifier that follows RFC 4122 format
+ * Format: 8-4-4-4-12 hexadecimal digits
+ * @example "550e8400-e29b-41d4-a716-446655440000"
+ * @see {@link https://tools.ietf.org/html/rfc4122 | RFC4122}
+ * @public
+ */
+declare type UUID = string;
+
+/**
+ * Represents a legacy V1 API asset format supporting both Notabene and CAIP-19 identifiers
+ *
+ * @remarks
+ * Used for backwards compatibility with V1 API transaction payloads:
+ * - Can be either a simple Notabene asset string
+ * - Or an object containing a CAIP-19 identifier
+ *
+ * @example "ETH_USDT" // Notabene asset format
+ * @example \{ caip19: "eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f" \} // CAIP-19 format
+ * @see {@link NotabeneAsset} For Notabene asset format
+ * @see {@link CAIP19} For CAIP-19 asset format
+ * @public
+ */
+declare type V1Asset = NotabeneAsset | {
     caip19: CAIP19;
-} | string;
+};
 
 /**
  * Transaction payload suitable for calling Notabene v1 tx/create
  * @public
  */
-declare type V1Transaction = {
+export declare type V1Transaction = {
     transactionAsset: V1Asset;
     transactionAmount: string;
     originatorEqualsBeneficiary?: boolean;
     originatorVASPdid: DID;
     beneficiaryVASPdid: DID;
-    beneficiaryProof: OwnershipProof;
-    originator: Originator;
+    beneficiaryProof?: OwnershipProof;
+    originator?: Originator;
     beneficiary: Beneficiary;
 };
 
-declare type ValidationError = {
+/**
+ * Validation error
+ * @public
+ */
+export declare type ValidationError = {
     attribute: string;
     message: string;
 };
 
+/**
+ * Sections in a WithdrawalAssist screen
+ *
+ * @alpha
+ */
+export declare enum ValidationSections {
+    ASSET = "asset",
+    DESTINATION = "destination",
+    COUNTERPARTY = "counterparty",
+    AGENT = "agent"
+}
+
 /**
  * A VASP agent acting on behalf of the counterparty
  * @public
  */
 export declare interface VASP extends Agent {
-    url?: string;
-    name?: string;
+    lei?: LEI;
+    logo?: URI;
+    website?: URI;
+    countryOfRegistration?: ISOCountryCode;
 }
 
+/**
+ * Options for which VASPs to be searchable
+ * @public
+ */
+export declare type VASPOptions = {
+    addUnknown?: boolean;
+    onlyActive?: boolean;
+};
+
 /**
  * A wallet agent acting on behalf of the counterparty
  * @public