/**
 * A blockchain account
 * @public
 */
export declare interface Account {
    did?: DID;
    blockchainAddress?: BlockchainAddress;
    chain?: CAIP2;
    caip10?: CAIP10;
    identifier?: string;
}

/**
 * Additional Document Reference
 * Reference to an additional document related to the invoice
 */
declare interface AdditionalDocumentReference {
    /**
     * Document identifier
     */
    id: string;
    /**
     * Type of document
     * Uses UBL Document Type Code standard
     */
    documentType?: DocumentTypeCode;
    /**
     * URL where the document can be accessed
     */
    url?: string;
}

/**
 * Address
 * Represents a physical address
 * @public
 */
declare type Address = {
    /** Identifies the nature of the address. */
    addressType: AddressTypeCode;
    /** Identification of a division of a large organisation or building. */
    department?: string;
    /** Identification of a sub-division of a large organisation or building. */
    subDepartment?: string;
    /** Name of a street or thoroughfare. */
    streetName?: string;
    /** Number that identifies the position of a building on a street. */
    buildingNumber?: string;
    /** Name of the building or house. */
    buildingName?: string;
    /** Floor or storey within a building. */
    floor?: string;
    /** Numbered box in a post office. */
    postBox?: string;
    /** Building room number. */
    room?: string;
    /** Identifier consisting of a group of letters and/or numbers that is added to a postal address to assist the sorting of mail. */
    postcode?: string;
    /** Name of a built-up area, with defined boundaries, and a local government. */
    townName: string;
    /** Specific location name within the town. */
    townLocationName?: string;
    /** Identifies a subdivision within a country subdivision. */
    districtName?: string;
    /** Identifies a subdivision of a country such as state, region, province. */
    countrySubDivision?: string;
    /** Information that locates and identifies a specific address, presented in free format text. */
    addressLine?: string[];
    /** Nation with its own government. */
    country: ISOCountryCode;
};

/**
 * Represents an address
 *
 * Per IVMS101 spec section 5.2.6.1, an address contains location information
 * that can be expressed either as:
 * - Structured fields (streetName, buildingNumber, etc.)
 * - Unstructured addressLine array (free-form text)
 *
 * Constraint C8 requires at least one of:
 * - addressLine OR
 * - (streetName AND (buildingName OR buildingNumber))
 */
declare interface Address_2 {
    /** Identifies the nature of the address */
    addressType: AddressTypeCode_2;
    /** Identification of a division of a large organisation or building */
    department?: string;
    /** Identification of a sub-division of a large organisation or building */
    subDepartment?: string;
    /** Name of a street or thoroughfare */
    streetName?: string;
    /** Number that identifies the position of a building on a street */
    buildingNumber?: string;
    /** Name of the building or house */
    buildingName?: string;
    /** Floor or storey within a building */
    floor?: string;
    /** Numbered box in a post office, assigned to a person or organisation, where letters are kept until called for */
    postBox?: string;
    /** Building room number */
    room?: string;
    /** Identifier consisting of a group of letters and/or numbers */
    postcode?: string;
    /** Name of a built-up area, with defined boundaries, and a local government */
    townName: string;
    /** Specific location name within the town */
    townLocationName?: string;
    /** Identifies a subdivision within a country subdivision */
    districtName?: string;
    /** Identifies a subdivision of a country */
    countrySubDivision?: string;
    /** Nation with its own government */
    country: CountryCode;
    /**
     * Information that locates and identifies a specific address, as defined by postal services,
     * presented in free format text.
     *
     * Array of 0 to 7 lines, each max 70 characters (Max70Text)
     * @maxItems 7
     */
    addressLine?: string[];
}

/**
 * Address Type Code
 * Specifies the type of address
 * @public
 */
declare type AddressTypeCode = 'HOME' | 'BIZZ' | 'GEOG';

/** Codes identifying the nature of an address */
declare type AddressTypeCode_2 = "HOME" | "BIZZ" | "GEOG";

/**
 * Who is the agent acting on behalf of the counterparty
 * @public
 */
export declare interface Agent {
    /**
     * Absent on a self-hosted agent chosen for a deposit without a `source`,
     * where there is no address to derive it from.
     */
    did?: DID;
    type: AgentType;
    logo?: URI;
    url?: URI;
    name?: string;
    verified?: boolean;
}

/**
 * Agent Interface
 * Represents software acting on behalf of participants in TAP transactions.
 * Agents handle communication, compliance, and transaction processing.
 *
 * @example
 * ```typescript
 * const originatorAgent: Agent = {
 *   "@id": "did:web:vasp.example.com",
 *   role: "SourceAddress",
 *   for: "did:example:customer123",
 *   name: "Example VASP Agent",
 *   leiCode: "969500KN90DZLPGW6898",
 *   url: "https://vasp.example.com",
 *   email: "compliance@vasp.example.com",
 *   geographicAddress: [{
 *     addressType: "HOME",
 *     streetName: "123 Main St",
 *     buildingNumber: "123",
 *     postCode: "12345",
 *     townName: "Example City",
 *     country: "US"
 *   }],
 *   policies: [{
 *     "@type": "RequireAuthorization",
 *     purpose: "AML compliance verification"
 *   }],
 *   serviceUrl: "https://vasp.example.com/didcomm"
 * };
 * ```
 */
declare interface Agent_2 extends Partial<Organization> {
    /**
     * Unique identifier for the participant
     * Can be either a DID or an IRI
     */
    "@id": DID_2 | IRI;
    /**
     * Role of the participant in the transaction
     * Standard values for Agents are: "SettlementAddress", "SourceAddress", "CustodialService"
     * All role values MUST use PascalCase
     * Optional for all participant types
     */
    role?: AgentRoles;
    /**
     * DID of the party this participant acts for
     * Used when participant is an agent acting on behalf of another party
     * Required for type "Agent", optional for other types
     * Can be a single DID or an array of DIDs representing multiple parties
     */
    for: DID_2 | DID_2[];
    /**
     * List of policies that apply to this participant
     * Defines requirements and constraints on the participant's actions
     */
    policies?: Policies[];
    /**
     * Optional DIDComm service endpoint URL
     * This field SHOULD only be used as a fallback when no DIDComm service endpoint
     * is resolvable from the agent's DID document. Particularly useful for self-hosted
     * and decentralized agents. For security purposes, this field SHOULD be ignored
     * if a valid DIDComm service endpoint is already listed in the DID document.
     *
     * @example "https://agent.example.com/didcomm"
     */
    serviceUrl?: IRI;
}

declare type AgentRoles = "SettlementAddress" | "SourceAddress" | "CustodialService" | "EscrowAgent" | string;

/**
 * Explicit layout configuration for the agent selection step.
 *
 * @remarks
 * Controls which options appear in the main selection area vs. behind the
 * "Can't find what you're looking for?" fallback toggle.
 *
 * When the main section has no options (empty or all filtered out), fallback options
 * are promoted and shown inline. When the main section has only one option, a dedicated
 * single-option layout is used.
 *
 * @public
 */
export declare interface AgentSections {
    /** Options shown in the main selection area (always visible) */
    main?: SectionOption[];
    /** Options shown behind the "Can't find what you're looking for?" fallback toggle */
    fallback?: SectionOption[];
}

/**
 * The type of Agent. Either a wallet or a VASP
 * @public
 */
export declare enum AgentType {
    PRIVATE = "WALLET",
    VASP = "VASP"
}

declare interface BaseRequestConfig {
    originatorId?: IRI;
    beneficiaryId?: IRI;
}

/**
 * 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;
};

declare type BeneficiaryV2 = {
    beneficiaryPerson: PersonV2[];
};

/**
 * Beneficiary VASP
 * Represents the VASP which receives the VA transfer
 * @public
 */
declare type BeneficiaryVASP = {
    /** The beneficiary VASP information */
    beneficiaryVASP?: Person;
};

/**
 * 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;

/**
 * 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}`;

/**
 * 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}`;

/**
 * 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}`;

/**
 * Options for callback and redirect URIs
 * @public
 */
export declare interface CallbackOptions {
    callback?: URI;
    redirectUri?: URI;
}

/**
 * Represents a cancel component message
 * @internal
 */
export declare type Cancel = {
    type: CMType.CANCEL;
};

/**
 * 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 enum CMType {
    COMPLETE = "complete",
    RESIZE = "resize",
    RESULT = "result",
    READY = "ready",
    INVALID = "invalid",
    ERROR = "error",
    CANCEL = "cancel",
    WARNING = "warning",
    INFO = "info"
}

/**
 * Status of a code verification
 * @public
 */
export declare enum CodeVerificationStatus {
    PENDING = "pending",
    APPROVED = "approved",
    FAILED = "failed",
    EXPIRED = "expired",
    MAX_ATTEMPTS_REACHED = "max_attempts_reached",
    UNREACHABLE = "unreachable"
}

/**
 * Represents a completed component message
 * @typeParam T - The overall Value type being returned
 * @typeParam R - The response type; defaults to `TransactionResponse<T>`
 * @param response - The Response object which wraps T
 * @public
 */
export declare type Completed<T, R = TransactionResponse<T>> = {
    type: CMType.COMPLETE;
    response: R;
};

/**
 * 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
 * - 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
 * @typeParam R - The response type carried by 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
 * @see {@link Warning} For warning message format
 * @see {@link Info} For info message format
 * @public
 */
export declare type ComponentMessage<T, R = TransactionResponse<T>> = Completed<T, R> | Cancel | Error_2 | Ready | ResizeRequest | InvalidValue<T> | Warning | Info;

/**
 * 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[];
}

/**
 * Transforms a Notabene component response to IVMS101 format
 *
 * ## IVMS101 Config by Transaction Type
 *
 * The `originator` and `beneficiary` config options provide the customer's PII data.
 * Which one to use depends on the transaction type:
 *
 * - **Withdrawals**: Pass `originator` - the customer is sending funds (customer = originator)
 * - **Deposits**: Pass `beneficiary` - the customer is receiving funds (customer = beneficiary)
 *
 * For self-transfers, the provided data is automatically reused for both parties.
 *
 * @param response - The response from the Notabene Embedded Component
 * @param delegateToken - The JWT delegate token for extracting the customer ID
 * @param config - Configuration object with optional IDs
 * @param config.originatorId - Optional originator ID (auto-extracted from delegateToken for withdrawals)
 * @param config.beneficiaryId - Optional beneficiary ID (auto-extracted from delegateToken for deposits)
 * @param config.originator - Customer's IVMS101 data for withdrawals (customer is the sender)
 * @param config.beneficiary - Customer's IVMS101 data for deposits (customer is the receiver)
 * @returns The transformed request body in IVMS101 format
 *
 * @example
 * ```typescript
 * import { componentResponseToIVMS101 } from '$lib/notabene-tx-transformer';
 *
 * // For withdrawals: pass originator (customer is sending)
 * const withdrawalIvms = componentResponseToIVMS101(
 *   withdrawalResponse,
 *   delegateToken,
 *   { originator: customerIvmsData }
 * );
 *
 * // For deposits: pass beneficiary (customer is receiving)
 * const depositIvms = componentResponseToIVMS101(
 *   depositResponse,
 *   delegateToken,
 *   { beneficiary: customerIvmsData }
 * );
 * ```
 */
export declare function componentResponseToIVMS101(response: TransactionResponse<Withdrawal | Deposit>, delegateToken: string, config?: ResponseToIVMS101RequestConfig): TransactionIVMS101Request;

/**
 * Transforms a Notabene component response to a Version 2 transaction create API request body
 *
 * @param response - The response from the Notabene Embedded Component
 * @param delegateToken - The JWT delegate token for extracting the originator ID
 * @param config - Configuration object with optional IDs
 * @param config.originatorId - Optional originator ID (auto-extracted from delegateToken if not provided)
 * @param config.beneficiaryId - Optional beneficiary ID (auto-generated if not provided)
 * @param config.referenceId - Optional reference ID for the transaction
 * @returns The transformed request body ready for the Version 2 transaction create API
 *
 * @example
 * ```typescript
 * import { componentResponseToTxCreateRequest } from '$lib/notabene-tx-transformer';
 *
 * // Works with both withdrawal and deposit responses
 * transaction.on('complete', async (result) => {
 *   const requestBody = componentResponseToTxCreateRequest(
 *     result.response,
 *     delegateToken,
 *     {
 *       originatorId: 'mailto:user@example.com',
 *       beneficiaryId: 'urn:beneficiary:recipient',
 *       referenceId: 'tx-12345'
 *     }
 *   );
 *
 *   await fetch('/entity/${vaspDid}/tx', {
 *     method: 'POST',
 *     body: JSON.stringify(requestBody)
 *   });
 * });
 * ```
 */
export declare function componentResponseToTxCreateRequest(response: TransactionResponse<Withdrawal | Deposit>, delegateToken: string, config?: ResponseToTxCreateRequestConfig): TransactionCreateRequestV2;

/**
 * Transforms a Notabene component response into txCreate, IVMS101, and confirmRelationship request bodies
 *
 * This is a convenience function that generates the transaction creation request,
 * the IVMS101 data, and optionally the relationship confirmation proof in a single call,
 * which is useful for V2 workflows where you need to create a transaction first,
 * then append IVMS101 data to it, and finally confirm the relationship.
 *
 * ## IVMS101 Config by Transaction Type
 *
 * The `originator` and `beneficiary` config options provide the customer's PII data.
 * Which one to use depends on the transaction type:
 *
 * - **Withdrawals**: Pass `originator` - the customer is sending funds (customer = originator)
 * - **Deposits**: Pass `beneficiary` - the customer is receiving funds (customer = beneficiary)
 *
 * For self-transfers, the provided data is automatically reused for both parties.
 *
 * @param response - The response from the Notabene Embedded Component
 * @param delegateToken - The JWT delegate token for extracting the customer ID
 * @param config - Optional configuration for IDs and reference
 * @param config.originatorId - Optional originator ID (auto-extracted from delegateToken for withdrawals)
 * @param config.beneficiaryId - Optional beneficiary ID (auto-extracted from delegateToken for deposits)
 * @param config.referenceId - Optional reference ID (auto-generated if not provided)
 * @param config.originator - Customer's IVMS101 data for withdrawals (customer is the sender)
 * @param config.beneficiary - Customer's IVMS101 data for deposits (customer is the receiver)
 * @returns Object with `createTx`, `ivms101`, and optional `confirmRelationship` properties containing the respective request bodies
 *
 * @example
 * ```typescript
 * import { componentResponseToTxRequests } from '$lib/notabene-tx-transformer';
 *
 * // For withdrawals: pass originator (customer is sending)
 * withdrawal.on('complete', async (result) => {
 *   const { createTx, ivms101 } = componentResponseToTxRequests(
 *     result.response,
 *     delegateToken,
 *     { originator: customerIvmsData }
 *   );
 * });
 *
 * // For deposits: pass beneficiary (customer is receiving)
 * deposit.on('complete', async (result) => {
 *   const { createTx, ivms101 } = componentResponseToTxRequests(
 *     result.response,
 *     delegateToken,
 *     { beneficiary: customerIvmsData }
 *   );
 * });
 * ```
 */
export declare function componentResponseToTxRequests(response: TransactionResponse<Withdrawal | Deposit>, delegateToken: string, config?: ResponseToTxRequestConfig): {
    createTx: TransactionCreateRequestV2;
    ivms101: TransactionIVMS101Request;
    confirmRelationship?: {
        proof: OwnershipProof;
    };
};

/**
 * @typeParam R - The counterparty's result. On v2.1, a link shared with a third party
 * carries the `{ transfer }` (`TransferResponse`).
 */
export declare interface ConnectionData<T extends ComponentRequest, R = TransactionResponse<T>> {
    readonly tx: T;
    readonly authToken?: string;
    readonly txOptions?: TransactionOptions;
    readonly result?: R;
    readonly phoneNumber?: string;
    readonly email?: string;
}

/**
 * Manages encrypted connections using Cloudflare Durable Objects
 */
export declare class ConnectionManager {
    private endpoint;
    constructor(endpoint: string);
    /**
     * Creates a new encrypted connection
     * @template T Type of component request
     * @param data The component request data to encrypt and store
     * @param metadata Connection metadata including participants and transaction type
     * @returns Promise resolving to connection details including ID, version, and encryption key
     */
    create<T extends ComponentRequest>(data: ConnectionData<T>, metadata: ConnectionMetadata): Promise<ConnectionResponse<T>>;
    /**
     * Updates an existing connection with new encrypted data
     * @template T Type of component request
     * @param id Connection ID
     * @param data New data to encrypt and store
     * @param version Current version number
     * @param status New connection status
     * @param key Current encryption key
     * @returns Promise resolving to updated connection details including new encryption key
     */
    update<T extends ComponentRequest, R = TransactionResponse<T>>(id: UUID, data: ConnectionData<T, R>, version: number, status: ConnectionStatus, key: string): Promise<ConnectionResponse<T, R>>;
    /**
     * Retrieves and decrypts connection data
     * @template T Type of component request
     * @param id Connection ID
     * @param key Encryption key from previous create/update operation
     * @returns Promise resolving to connection details including decrypted data
     */
    get<T extends ComponentRequest>(id: UUID, key: string): Promise<ConnectionResponse<T>>;
    /**
     * Closes a connection
     * @param id Connection ID
     * @returns Promise resolving when the connection is closed
     */
    close(id: UUID): Promise<void>;
}

export declare interface ConnectionMetadata {
    readonly nodeUrl?: string;
    readonly participants: readonly string[];
    readonly transactionType: TransactionType;
    readonly locale?: string;
    /**
     * Delivery target for Counterparty Assist completion/closure webhooks.
     * Sent and stored as plaintext so the connection can route the event, so do not
     * embed secrets (e.g. `?token=`) in this URL. Webhook payloads carry the encrypted
     * `sealed` blob, whose successful decryption is itself an authenticity check;
     * signed delivery is provided by the future Svix-backed pipeline.
     */
    readonly webhookUrl?: string;
}

/**
 * An object representing options for a Connection Request
 * @public
 */
export declare type ConnectionOptions = Omit<TransactionOptions, 'allowedAgentTypes' | 'allowedCounterpartyTypes' | 'vasps' | 'fields' | 'hide'>;

/**
 * An object representing a connection request
 * @public
 */
export declare interface ConnectionRequest extends ComponentRequest {
    asset: TransactionAsset;
    /**
     * The account to collect a proof for.
     *
     * @remarks
     * When set, the component narrows the connected wallet to this account and
     * only offers to verify that one, instead of letting the user pick any
     * address the wallet reports. Connecting fails if the wallet does not hold
     * it. When omitted, the user chooses which of their addresses to prove.
     *
     * A bare blockchain address is resolved against the chain of {@link ConnectionRequest.asset}.
     *
     * @see {@link OwnershipProof.address} For the proved account on the response
     */
    address?: BlockchainAddress | CAIP10;
}

export declare interface ConnectionResponse<T extends ComponentRequest, R = TransactionResponse<T>> {
    readonly id: UUID;
    readonly version: number;
    readonly status: ConnectionStatus;
    readonly metadata: ConnectionMetadata;
    readonly data: ConnectionData<T, R>;
    readonly key: string;
}

export declare type ConnectionResult<T extends ComponentRequest> = {
    readonly id: UUID;
    readonly metadata: ConnectionMetadata;
    readonly status: 'closed';
} | {
    readonly id: UUID;
    readonly metadata: ConnectionMetadata;
    readonly status: 'completed';
    readonly result: TransactionResponse<T>;
} | {
    readonly id: UUID;
    readonly metadata: ConnectionMetadata;
    readonly status: 'active';
    readonly tx: T;
};

export declare type ConnectionStatus = 'active' | 'completed' | 'closed';

/**
 * Configuration for the terms and conditions consent checkbox.
 *
 * @remarks
 * - `undefined` or `true`: show default T&C (current behavior)
 * - `false`: hide T&C entirely
 * - `{ label?, description? }`: show with custom text (translations are the customer's responsibility)
 *
 * @public
 */
export declare type ConsentConfig = boolean | {
    /** Custom label text. Replaces the default "Accept terms and conditions". */
    label?: string;
    /** Custom description text. Replaces the default sharing-info description. */
    description?: string;
};

/**
 * Configuration for the contact support action.
 *
 * @remarks
 * Contact support is **enabled** by including `'contact-support'` in
 * `agentSections.main` or `agentSections.fallback`. This object only
 * configures the behaviour when the feature is enabled.
 *
 * - With `contactSupport: { supportUrl: "..." }` — clicking sends an info
 *   message to the host **and** attempts to open the URL as a fallback.
 * - Without `contactSupport` — clicking only sends an info message; the
 *   host decides what to do.
 *
 * @public
 */
export declare interface ContactSupportConfig {
    /** URL to open when the user clicks the support button */
    supportUrl: string;
}

/**
 * Metadata for Cosmos ownership proofs
 * @remarks
 * - Includes the public key
 * @public
 */
export declare interface CosmosMetadata {
    pub_key: {
        type: string;
        value: string;
    };
}

/**
 * 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?: DID;
    type?: PersonType;
    verified?: boolean;
    geographicAddress?: Address;
    nationalIdentification?: NationalIdentification;
    website?: URI;
    phone?: string;
    email?: string;
}

/**
 * Counterparty Assist Configuration options for recipient selection
 *
 * @remarks
 * Controls for each person type, whether to show the share feature or not.
 *
 * @public
 */
export declare type CounterpartyAssistConfig = boolean | {
    counterpartyTypes: PersonType[];
    /** @remarks Requires a transactionId to be passed in. */
    identityVerification?: IdentityVerificationConfig;
    /**
     * Optional URL that receives an `EC.counterpartyAssist*` webhook when the
     * counterparty completes or closes their part. MVP-only per-link override;
     * superseded by Portal-managed subscriptions post-migration.
     *
     * Transmitted and stored as plaintext, so do not embed secrets (e.g. `?token=`)
     * in this URL. Payloads carry the encrypted `sealed` blob (a successful decrypt
     * is itself an authenticity check); signed delivery is provided by the future
     * Svix-backed pipeline.
     */
    webhookUrl?: string;
};

declare type CountryCode = "AF" | "AL" | "DZ" | "AS" | "AD" | "AO" | "AI" | "AQ" | "AG" | "AR" | "AM" | "AW" | "AU" | "AT" | "AZ" | "BS" | "BH" | "BD" | "BB" | "BY" | "BE" | "BZ" | "BJ" | "BM" | "BT" | "BO" | "BQ" | "BA" | "BW" | "BV" | "BR" | "IO" | "BN" | "BG" | "BF" | "BI" | "CV" | "KH" | "CM" | "CA" | "KY" | "CF" | "TD" | "CL" | "CN" | "CX" | "CC" | "CO" | "KM" | "CD" | "CG" | "CK" | "CR" | "HR" | "CU" | "CW" | "CY" | "CZ" | "CI" | "DK" | "DJ" | "DM" | "DO" | "EC" | "EG" | "SV" | "GQ" | "ER" | "EE" | "SZ" | "ET" | "FK" | "FO" | "FJ" | "FI" | "FR" | "GF" | "PF" | "TF" | "GA" | "GM" | "GE" | "DE" | "GH" | "GI" | "GR" | "GL" | "GD" | "GP" | "GU" | "GT" | "GG" | "GN" | "GW" | "GY" | "HT" | "HM" | "VA" | "HN" | "HK" | "HU" | "IS" | "IN" | "ID" | "IR" | "IQ" | "IE" | "IM" | "IL" | "IT" | "JM" | "JP" | "JE" | "JO" | "KZ" | "KE" | "KI" | "KP" | "KR" | "KW" | "KG" | "LA" | "LV" | "LB" | "LS" | "LR" | "LY" | "LI" | "LT" | "LU" | "MO" | "MG" | "MW" | "MY" | "MV" | "ML" | "MT" | "MH" | "MQ" | "MR" | "MU" | "YT" | "MX" | "FM" | "MD" | "MC" | "MN" | "ME" | "MS" | "MA" | "MZ" | "MM" | "NA" | "NR" | "NP" | "NL" | "NC" | "NZ" | "NI" | "NE" | "NG" | "NU" | "NF" | "MK" | "MP" | "NO" | "OM" | "PK" | "PW" | "PS" | "PA" | "PG" | "PY" | "PE" | "PH" | "PN" | "PL" | "PT" | "PR" | "QA" | "RO" | "RU" | "RW" | "RE" | "BL" | "SH" | "KN" | "LC" | "MF" | "PM" | "VC" | "WS" | "SM" | "ST" | "SA" | "SN" | "RS" | "SC" | "SL" | "SG" | "SX" | "SK" | "SI" | "SB" | "SO" | "ZA" | "GS" | "SS" | "ES" | "LK" | "SD" | "SR" | "SJ" | "SE" | "CH" | "SY" | "TW" | "TJ" | "TZ" | "TH" | "TL" | "TG" | "TK" | "TO" | "TT" | "TN" | "TR" | "TM" | "TC" | "TV" | "UG" | "UA" | "AE" | "GB" | "UM" | "US" | "UY" | "UZ" | "VU" | "VE" | "VN" | "VG" | "VI" | "WF" | "EH" | "YE" | "ZM" | "ZW" | "AX" | "XX";

/**
 * A crypto credential
 * @public
 */ export declare type CryptoCredential = `${string}.${string}.mastercard`;

/**
 * Date and Place of Birth
 * Represents the date and place of birth for a natural person
 * @public
 */
declare type DateAndPlaceOfBirth = {
    /** Date of birth in ISO 8601 format (YYYY-MM-DD) */
    dateOfBirth?: ISODate;
    /** Place of birth (max 70 characters) */
    placeOfBirth?: string;
};

/**
 * Ownership Proof using Self Declaration
 * @public
 */
export declare interface DeclarationProof extends OwnershipProof {
    type: ProofTypes.SelfDeclaration;
    attestation: string;
    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>;

/**
 * Decrypt a Counterparty Assist webhook payload with the key the VASP captured
 * at connection creation. Single call, no network fetch (the webhook already
 * carried the ciphertext).
 * @public
 */
export declare function decryptCounterpartyAssistPayload<T>({ sealed, key, }: {
    sealed: string;
    key: string;
}): Promise<T>;

/**
 * An object representing a deposit transaction
 * @public
 */
export declare interface Deposit extends OriginatorFields, Transaction, Refreshable {
}

/**
 * An object representing a request for a deposit
 * @public
 */
export declare interface DepositRequest extends DepositRequestFields, ComponentRequest {
}

/**
 * Fields specific to a deposit request
 * @public
 */
declare type DepositRequestFields = {
    destination: BlockchainAddress | CAIP10;
    asset: TransactionAsset;
    amountDecimal: string | number;
    travelAddress?: TravelAddress;
    cryptoCredential?: CryptoCredential;
};

/**
 * An object representing options for a Deposit Request
 * @public
 */
export 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;

/**
 * A Decentralized Identifier
 * @public
 */
export declare type DID = `did:${string}:${string}`;

/**
 * Decentralized Identifier (DID)
 * A globally unique persistent identifier that doesn't require a centralized registration authority.
 *
 * Format: `did:method:method-specific-id`
 *
 * @example "did:web:example.com"
 * @example "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK"
 * @see {@link https://www.w3.org/TR/did-core/ | DID Core Specification}
 */
declare type DID_2 = `did:${string}:${string}`;

/**
 * UBL Document Type Code standard
 * Based on UBL 2.1 document types
 *
 * @see {@link http://docs.oasis-open.org/ubl/os-UBL-2.1/cl/gc/default/DocumentTypeCode-2.1.gc | UBL Document Type Codes}
 */
declare enum DocumentTypeCode {
    Order = "Order",
    OrderResponse = "OrderResponse",
    OrderChange = "OrderChange",
    OrderCancellation = "OrderCancellation",
    Quotation = "Quotation",
    DespatchAdvice = "DespatchAdvice",
    ReceiptAdvice = "ReceiptAdvice",
    Invoice = "Invoice",
    CreditNote = "CreditNote",
    DebitNote = "DebitNote",
    SelfBilledInvoice = "SelfBilledInvoice",
    RemittanceAdvice = "RemittanceAdvice",
    Statement = "Statement",
    CertificateOfOrigin = "CertificateOfOrigin",
    Contract = "Contract",
    Timesheet = "Timesheet",
    Waybill = "Waybill",
    Manifest = "Manifest"
}

/**
 * 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
 *
 * @typeParam V - The transaction value type
 * @typeParam O - The options type
 * @typeParam R - The response type that `completion()` resolves with
 * @public
 */
export declare class EmbeddedComponent<V, O, R = TransactionResponse<V>> {
    private _url;
    private _value;
    private _options?;
    private _errors;
    private iframe?;
    private eventManager;
    private modal?;
    private messageHandler?;
    private tokenRefresher?;
    private authToken?;
    /**
     * Creates an instance of EmbeddedComponent.
     * @param url - The URL of the embedded component
     * @param value - The initial transaction value
     * @param fetchToken - Supplies the auth token, and refreshes it before it expires
     * @internal
     */
    constructor(url: string, value: Partial<V>, options?: O, fetchToken?: () => Promise<string>);
    /**
     * Gets the URL of the embedded component. With `fetchToken` configured the URL
     * carries no token, since it is fetched when the component is shown.
     * @returns The URL of the embedded component
     */
    get url(): string;
    /**
     * Gets the current transaction value
     * @returns The current transaction value
     */
    get value(): Partial<V>;
    get options(): O | undefined;
    get errors(): ValidationError[];
    private urlWithToken;
    private tokenError;
    /**
     * 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, modal?: boolean): void;
    private connectPort;
    /**
     * Fetches the first token and navigates with it, then posts each refreshed
     * token to the component until the target is gone.
     */
    private startRefresh;
    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, R>): () => 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, R>): 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<R>;
    /**
     * Opens the component in a modal dialog
     */
    openModal(): Promise<R>;
    /**
     * Closes the modal dialog
     *
     */
    closeModal(): void;
    /**
     * Opens the component in a popup window. This may be needed to support many self-hosted wallets
     * @returns A promise that resolves with the transaction response
     * @see [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/open#restrictions)
     * @see [Cross-Origin-Opener-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Opener-Policy)
     */
    popup(): Promise<R>;
}

/**
 * Represents an error component message
 * @param message - Error message
 * @param description - Description of the error message
 * @param identifier - Identifier code of the error message
 * @public
 */
declare type Error_2 = {
    type: CMType.ERROR;
    message: string;
    description?: string;
    identifier?: ErrorIdentifierCode;
};
export { Error_2 as Error }

/**
 * Represents an error identifier code
 * @public
 */
export declare enum ErrorIdentifierCode {
    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
    WALLET_CONNECTION_FAILED = "WALLET_CONNECTION_FAILED",
    WALLET_NOT_SUPPORTED = "WALLET_NOT_SUPPORTED",
    TOKEN_INVALID = "TOKEN_INVALID"
}

/**
 * Field properties
 * @public
 */
export declare type FieldOptions = boolean | string[] | {
    optional: boolean;
};

/**
 * Field type configuration
 * @public
 */
export declare type FieldTypes = {
    naturalPerson?: NaturalPersonFields;
    legalPerson?: LegalPersonFields;
};

/**
 * Retrieves and processes connection refresh data
 * @template T Type of component request
 * @param refreshSource Source information for the refresh operation
 * @returns Promise resolving to connection result with decrypted data
 */
export declare function getRefreshResult<T extends ComponentRequest>(refreshSource: Pick<RefreshSource, 'url' | 'key'>): Promise<ConnectionResult<T>>;

/**
 * A section of a WithdrawalAssist or DepositAssist screen that can be left out,
 * via {@link TransactionOptions.hide}.
 *
 * `'header'` is the card header — its status icon, title, description and
 * participant logo. The card body and footer are unaffected, so the Notabene
 * attribution in the footer still shows.
 *
 * @public
 */
export declare type HideSection = 'asset' | 'destination' | 'counterparty' | 'agent' | 'header';

/**
 * 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
 * - TOKEN: Message delivering a refreshed delegate token to the component
 * @public
 */
export declare enum HMType {
    UPDATE = "update",
    REQUEST_RESPONSE = "requestResponse",
    TOKEN = "token"
}

/**
 * Union type representing all possible messages that can be sent from the host application
 * to a component
 *
 * @remarks
 * Supports update messages, which allow the host to modify component state and
 * configuration without requiring full reinitialization, and token messages, which
 * deliver a refreshed delegate token.
 *
 * @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 RefreshToken} For the structure of token messages
 * @see {@link HMType} For message type constants
 * @public
 */
export declare type HostMessage<T, O> = UpdateValue<T, O> | RefreshToken;

/**
 * Configuration options for identity verification
 * @public
 */
declare type IdentityVerificationConfig = {
    /** The required verification method. If not specified, none will be used */
    requiredMethod?: IdentityVerificationMethod;
};

/**
 * Available methods for identity verification
 * @public
 */
export declare enum IdentityVerificationMethod {
    SMS = "sms"
}

/**
 * Represents an info component message
 * @param message - Info message
 * @param description - Description of the info message
 * @param identifier - Identifier code of the info message
 * @public
 */
declare type Info = {
    type: CMType.INFO;
    message: string;
    description?: string;
    identifier?: InfoIdentifierCode;
};

/**
 * Identifier codes for info messages
 * @public
 */
export declare enum InfoIdentifierCode {
    CONTACT_SUPPORT = "CONTACT_SUPPORT"
}

/**
 * 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
 * @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: Partial<T>;
    errors: ValidationError[];
};

/**
 * Invoice
 * Represents a detailed invoice as defined in TAIP-16
 *
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-16.md | TAIP-16: Invoices}
 */
export declare interface Invoice {
    /**
     * Unique identifier for the invoice
     *
     * @example "INV001"
     * @validation Must be a unique identifier for the invoice
     */
    id: string;
    /**
     * Date when the invoice was issued
     * ISO 8601 date format (YYYY-MM-DD)
     *
     * @example "2025-04-22"
     * @validation Must be a valid date in ISO 8601 format
     */
    issueDate: string;
    /**
     * Currency code for the invoice amounts
     * ISO 4217 currency code
     * Should be consistent with the currency field in the Payment Request if present
     *
     * @example "USD"
     * @example "EUR"
     * @validation Must be a valid ISO 4217 currency code
     */
    currencyCode: IsoCurrency;
    /**
     * Individual items being invoiced
     *
     * @validation Must be an array of LineItem objects
     */
    lineItems: LineItem[];
    /**
     * Aggregate tax information
     *
     * @validation Must be a TaxTotal object if present
     */
    taxTotal?: TaxTotal;
    /**
     * Total amount of the invoice, including taxes
     * Must match the amount in the Payment Request body
     *
     * @validation Must be a positive number
     */
    total: number;
    /**
     * Sum of line totals before taxes
     *
     * @validation Must be a positive number if present
     */
    subTotal?: number;
    /**
     * Date when payment is due
     * ISO 8601 date format (YYYY-MM-DD)
     *
     * @example "2025-05-22"
     * @validation Must be a valid date in ISO 8601 format if present
     */
    dueDate?: string;
    /**
     * Additional notes or terms for the invoice
     *
     * @validation Must be a string if present
     */
    note?: string;
    /**
     * Terms of payment
     *
     * @example "Net 30"
     * @validation Must be a string if present
     */
    paymentTerms?: string;
    /**
     * Buyer's accounting code
     * Used to route costs to specific accounts
     *
     * @validation Must be a string if present
     */
    accountingCost?: string;
    /**
     * Reference to a related order
     *
     * @validation Must be an OrderReference object if present
     */
    orderReference?: OrderReference;
    /**
     * References to additional documents
     *
     * @validation Must be an array of AdditionalDocumentReference objects if present
     */
    additionalDocumentReference?: AdditionalDocumentReference[];
}

/** Output fields populated by the component on completion */
export declare interface InvoiceReaderResponse {
    /** TAIP-16 compliant invoice data (populated by the component after PDF parsing) */
    invoice?: Invoice;
    merchant?: Party;
    customer?: Party;
}

/**
 * Internationalized Resource Identifier (IRI)
 * A unique identifier that may contain international characters.
 * Used for identifying resources, particularly in JSON-LD contexts.
 *
 * @see {@link https://www.w3.org/TR/json-ld11/#iris | JSON-LD 1.1 IRIs}
 */
declare type IRI = `${string}:${string}`;

/**
 * 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;

/**
 * ISO 4217 Currency Codes
 * Three-letter codes representing currencies according to the ISO 4217 standard.
 *
 * @see {@link https://www.iso.org/iso-4217-currency-codes.html | ISO 4217}
 */
declare type IsoCurrency = 
/** United Arab Emirates Dirham */
"AED"
/** Afghan Afghani */
| "AFN"
/** Albanian Lek */
| "ALL"
/** Armenian Dram */
| "AMD"
/** Netherlands Antillean Guilder */
| "ANG"
/** Angolan Kwanza */
| "AOA"
/** Argentine Peso */
| "ARS"
/** Australian Dollar */
| "AUD"
/** Aruban Florin */
| "AWG"
/** Azerbaijani Manat */
| "AZN"
/** Bosnia and Herzegovina Convertible Mark */
| "BAM"
/** Barbados Dollar */
| "BBD"
/** Bangladeshi Taka */
| "BDT"
/** Bulgarian Lev */
| "BGN"
/** Bahraini Dinar */
| "BHD"
/** Burundian Franc */
| "BIF"
/** Bermudian Dollar */
| "BMD"
/** Brunei Dollar */
| "BND"
/** Boliviano */
| "BOB"
/** Brazilian Real */
| "BRL"
/** Bahamian Dollar */
| "BSD"
/** Bhutanese Ngultrum */
| "BTN"
/** Botswana Pula */
| "BWP"
/** Belarusian Ruble */
| "BYN"
/** Belize Dollar */
| "BZD"
/** Canadian Dollar */
| "CAD"
/** Congolese Franc */
| "CDF"
/** Swiss Franc */
| "CHF"
/** Chilean Peso */
| "CLP"
/** Chinese Yuan */
| "CNY"
/** Colombian Peso */
| "COP"
/** Costa Rican Colon */
| "CRC"
/** Cuban Peso */
| "CUP"
/** Cape Verde Escudo */
| "CVE"
/** Czech Koruna */
| "CZK"
/** Djiboutian Franc */
| "DJF"
/** Danish Krone */
| "DKK"
/** Dominican Peso */
| "DOP"
/** Algerian Dinar */
| "DZD"
/** Egyptian Pound */
| "EGP"
/** Eritrean Nakfa */
| "ERN"
/** Ethiopian Birr */
| "ETB"
/** Euro */
| "EUR"
/** Fiji Dollar */
| "FJD"
/** Falkland Islands Pound */
| "FKP"
/** Pound Sterling */
| "GBP"
/** Georgian Lari */
| "GEL"
/** Ghanaian Cedi */
| "GHS"
/** Gibraltar Pound */
| "GIP"
/** Gambian Dalasi */
| "GMD"
/** Guinean Franc */
| "GNF"
/** Guatemalan Quetzal */
| "GTQ"
/** Guyanese Dollar */
| "GYD"
/** Hong Kong Dollar */
| "HKD"
/** Honduran Lempira */
| "HNL"
/** Croatian Kuna */
| "HRK"
/** Haitian Gourde */
| "HTG"
/** Hungarian Forint */
| "HUF"
/** Indonesian Rupiah */
| "IDR"
/** Israeli New Shekel */
| "ILS"
/** Indian Rupee */
| "INR"
/** Iraqi Dinar */
| "IQD"
/** Iranian Rial */
| "IRR"
/** Icelandic Króna */
| "ISK"
/** Jamaican Dollar */
| "JMD"
/** Jordanian Dinar */
| "JOD"
/** Japanese Yen */
| "JPY"
/** Kenyan Shilling */
| "KES"
/** Kyrgyzstani Som */
| "KGS"
/** Cambodian Riel */
| "KHR"
/** Comoro Franc */
| "KMF"
/** North Korean Won */
| "KPW"
/** South Korean Won */
| "KRW"
/** Kuwaiti Dinar */
| "KWD"
/** Cayman Islands Dollar */
| "KYD"
/** Kazakhstani Tenge */
| "KZT"
/** Lao Kip */
| "LAK"
/** Lebanese Pound */
| "LBP"
/** Sri Lankan Rupee */
| "LKR"
/** Liberian Dollar */
| "LRD"
/** Lesotho Loti */
| "LSL"
/** Libyan Dinar */
| "LYD"
/** Moroccan Dirham */
| "MAD"
/** Moldovan Leu */
| "MDL"
/** Malagasy Ariary */
| "MGA"
/** Macedonian Denar */
| "MKD"
/** Myanmar Kyat */
| "MMK"
/** Mongolian Tugrik */
| "MNT"
/** Macanese Pataca */
| "MOP"
/** Mauritanian Ouguiya */
| "MRU"
/** Mauritian Rupee */
| "MUR"
/** Maldivian Rufiyaa */
| "MVR"
/** Malawian Kwacha */
| "MWK"
/** Mexican Peso */
| "MXN"
/** Malaysian Ringgit */
| "MYR"
/** Mozambican Metical */
| "MZN"
/** Namibian Dollar */
| "NAD"
/** Nigerian Naira */
| "NGN"
/** Nicaraguan Córdoba */
| "NIO"
/** Norwegian Krone */
| "NOK"
/** Nepalese Rupee */
| "NPR"
/** New Zealand Dollar */
| "NZD"
/** Omani Rial */
| "OMR"
/** Panamanian Balboa */
| "PAB"
/** Peruvian Sol */
| "PEN"
/** Papua New Guinean Kina */
| "PGK"
/** Philippine Peso */
| "PHP"
/** Pakistani Rupee */
| "PKR"
/** Polish Złoty */
| "PLN"
/** Paraguayan Guaraní */
| "PYG"
/** Qatari Riyal */
| "QAR"
/** Romanian Leu */
| "RON"
/** Serbian Dinar */
| "RSD"
/** Russian Ruble */
| "RUB"
/** Rwandan Franc */
| "RWF"
/** Saudi Riyal */
| "SAR"
/** Solomon Islands Dollar */
| "SBD"
/** Seychelles Rupee */
| "SCR"
/** Sudanese Pound */
| "SDG"
/** Swedish Krona */
| "SEK"
/** Singapore Dollar */
| "SGD"
/** Saint Helena Pound */
| "SHP"
/** Sierra Leonean Leone */
| "SLL"
/** Somali Shilling */
| "SOS"
/** Surinamese Dollar */
| "SRD"
/** South Sudanese Pound */
| "SSP"
/** São Tomé and Príncipe Dobra */
| "STN"
/** Salvadoran Colón */
| "SVC"
/** Syrian Pound */
| "SYP"
/** Swazi Lilangeni */
| "SZL"
/** Thai Baht */
| "THB"
/** Tajikistani Somoni */
| "TJS"
/** Turkmenistan Manat */
| "TMT"
/** Tunisian Dinar */
| "TND"
/** Tongan Paʻanga */
| "TOP"
/** Turkish Lira */
| "TRY"
/** Trinidad and Tobago Dollar */
| "TTD"
/** New Taiwan Dollar */
| "TWD"
/** Tanzanian Shilling */
| "TZS"
/** Ukrainian Hryvnia */
| "UAH"
/** Ugandan Shilling */
| "UGX"
/** United States Dollar */
| "USD"
/** Uruguayan Peso */
| "UYU"
/** Uzbekistan Som */
| "UZS"
/** Venezuelan Bolívar Soberano */
| "VES"
/** Vietnamese Đồng */
| "VND"
/** Vanuatu Vatu */
| "VUV"
/** Samoan Tala */
| "WST"
/** CFA Franc BEAC */
| "XAF"
/** East Caribbean Dollar */
| "XCD"
/** CFA Franc BCEAO */
| "XOF"
/** CFP Franc */
| "XPF"
/** Yemeni Rial */
| "YER"
/** South African Rand */
| "ZAR"
/** Zambian Kwacha */
| "ZMW"
/** Zimbabwean Dollar */
| "ZWL";

/**
 * 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
 *
 * @public
 */
export declare type IVMS101 = {
    originator?: Originator;
    beneficiary?: Beneficiary;
    originatingVASP?: OriginatingVASP;
    beneficiaryVASP?: BeneficiaryVASP;
    transferPath?: TransferPath;
    payloadMetadata?: PayloadMetadata;
};

/**
 * Base interface for JSON-LD objects
 * Provides the core structure for JSON-LD compatible objects with type information.
 *
 * @template T - The type string that identifies the object type
 */
declare interface JsonLdObject<T extends string> {
    "@context"?: IRI | Record<string, string>;
    "@type": T;
}

/**
 * Ids of the wallets the embedded component always offers under a fixed id.
 *
 * `'ledger-usb-wallet'` and `'ledger-bluetooth-wallet'` are the two Ledger transports,
 * `'trezor'` is Trezor over Trezor Connect, and `'wallet-connect'` is the WalletConnect
 * (Reown AppKit) card that lists mobile wallets.
 *
 * @public
 */
export declare type KnownWalletId = 'ledger-usb-wallet' | 'ledger-bluetooth-wallet' | 'trezor' | 'wallet-connect';

declare type LegalEntityNationalIdentifierTypeCode = Omit<NationalIdentifierTypeCode_2, "ARNU" | "CCPT" | "DRLC" | "SOCS" | "IDCD">;

/**
 * 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_2 = {
    /** The name of the legal person */
    name: LegalPersonName;
    /** The address of the legal person */
    geographicAddress?: Address[];
    /** 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 */
    nationalIdentification?: NationalIdentification;
    /** The country in which the legal person is registered */
    countryOfRegistration?: ISOCountryCode;
};

export declare type LegalPersonFieldName = 'name' | 'lei' | 'website' | 'email' | 'phone' | 'geographicAddress' | 'nationalIdentification' | 'countryOfRegistration';

/**
 * Field properties for legal person fields
 * @public
 */
export declare type LegalPersonFields = Partial<{
    name: FieldOptions;
    lei: FieldOptions;
    website: FieldOptions;
    email: FieldOptions;
    phone: FieldOptions;
    geographicAddress: FieldOptions;
    nationalIdentification: FieldOptions & {
        nationalIdentifierType: NationalIdentifierTypeFieldOptions;
    };
    countryOfRegistration: 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[];
};

/**
 * Legal Person Name ID
 * Represents a name identifier for a legal person
 * @public
 */
declare type LegalPersonNameID = {
    /** Name by which the legal person is known */
    legalPersonName: string;
    /** The nature of the name specified */
    legalPersonNameIdentifierType: LegalPersonNameTypeCode;
};

/** Represents a legal person's name identifier */
declare interface LegalPersonNameId {
    /** Name by which the legal person is known */
    legalPersonName: string;
    /** The nature of the name specified */
    legalPersonNameIdentifierType: LegalPersonNameTypeCode_2;
}

/**
 * Legal Person Name Type Code
 * Specifies the type of name for a legal person
 * @public
 */
declare type LegalPersonNameTypeCode = 'LEGL' | 'SHRT' | 'TRAD';

/** Codes representing the nature of a legal person's name */
declare type LegalPersonNameTypeCode_2 = "LEGL" | "SHRT" | "TRAD";

/**
 * A LEI Legal Entity Identifier
 * @public
 */
export declare type LEI = string;

/**
 * Legal Entity Identifier (LEI)
 * A 20-character alphanumeric code that uniquely identifies legal entities globally.
 *
 * @example "969500KN90DZLPGW6898"
 * @see {@link https://www.iso.org/standard/59771.html | ISO 17442}
 */
declare type LEICode = string;

/**
 * Line Item
 * Represents an individual item in an invoice
 */
declare interface LineItem {
    /**
     * Unique identifier for the line item within the invoice
     */
    id: string;
    /**
     * Description of the item or service
     */
    description: string;
    /**
     * Product name
     * Based on schema.org/Product
     * If not provided, description serves as the display name
     *
     * @example "Premium Widget Model A"
     */
    name?: string;
    /**
     * URL to an image of the product
     * Based on schema.org/Product
     *
     * @example "https://example.com/products/widget-a.jpg"
     */
    image?: string;
    /**
     * URL to the product page
     * Based on schema.org/Product
     *
     * @example "https://example.com/products/widget-a"
     */
    url?: string;
    /**
     * Quantity of the item
     */
    quantity: number;
    /**
     * Unit of measure code
     * Uses UBL Unit of Measure Code standard
     *
     * @example UnitCode.Each
     * @example UnitCode.Kilogram
     * @example UnitCode.Hour
     */
    unitCode?: UnitCode;
    /**
     * Price per unit
     */
    unitPrice: number;
    /**
     * Total amount for this line item
     * Typically quantity × unitPrice
     */
    lineTotal: number;
    /**
     * Tax category information specific to this line item
     */
    taxCategory?: TaxCategory;
}

/**
 * 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;
};

/**
 * 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;
};

/**
 * Callback function for handling component messages.
 *
 * @typeParam T - The type of data contained in the component message
 * @typeParam R - The response type carried by completion messages
 * @param message - The message object containing the component data and type
 * @public
 */
export declare type MessageCallback<T, R = TransactionResponse<T>> = (message: ComponentMessage<T, R>) => void;

/**
 * Ownership Proof using Micro Transfer
 * @public
 */
export declare interface MicroTransferProof extends OwnershipProof {
    type: ProofTypes.MicroTransfer;
    proof: string;
    chain: CAIP2;
    asset: CAIP19;
    destination: BlockchainAddress;
    amountSubunits: string;
}

/**
 * National Identification
 * Represents a national identifier for a person or entity
 * @public
 */
export declare type NationalIdentification = {
    /** National identifier (max 35 characters) */
    nationalIdentifier?: string;
    /** Type of national identifier */
    nationalIdentifierType?: NationalIdentifierTypeCode;
    /** Country that issued the national identifier */
    countryOfIssue?: ISOCountryCode;
    /** Registration authority (format: RA followed by 6 digits) */
    registrationAuthority?: string;
};

/** Represents a national identification */
declare interface NationalIdentification_2<C> {
    /** An identifier issued by an appropriate issuing authority */
    nationalIdentifier: string;
    /** Specifies the type of identifier */
    nationalIdentifierType: C;
    /** Country of the issuing authority */
    countryOfIssue?: CountryCode;
    /** A code specifying the registration authority */
    registrationAuthority?: string;
}

/**
 * National Identifier Type Code
 * Specifies the type of national identifier
 * @public
 */
declare type NationalIdentifierTypeCode = 'ARNU' | 'CCPT' | 'RAID' | 'DRLC' | 'FIIN' | 'TXID' | 'SOCS' | 'IDCD' | 'LEIX' | 'MISC';

/**
 * Codes identifying the type of national identification
 *
 * - **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
 * - **MISC**: Miscellaneous - Other types of national identification not covered by the above codes
 */
declare type NationalIdentifierTypeCode_2 = "ARNU" | "CCPT" | "RAID" | "DRLC" | "FIIN" | "TXID" | "SOCS" | "IDCD" | "LEIX" | "MISC";

/**
 * Field properties for national identifier type selection
 * @public
 */
declare type NationalIdentifierTypeFieldOptions = {
    values?: NationalIdentifierTypeCode[];
};

/**
 * 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_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 */
    geographicAddress?: Address[];
    /** 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 */
    customerIdentification?: string;
    /** Date and place of birth of a person */
    dateAndPlaceOfBirth?: DateAndPlaceOfBirth;
    /** Country in which a person resides (the place of a person's home) */
    countryOfResidence?: ISOCountryCode;
};

/**
 * Field names for NaturalPerson
 * @public
 */
export declare type NaturalPersonFieldName = 'name' | 'website' | 'email' | 'phone' | 'geographicAddress' | 'nationalIdentification' | 'dateOfBirth' | 'placeOfBirth' | 'countryOfResidence';

/**
 * Field properties for natural person fields
 * @public
 */
export declare type NaturalPersonFields = Partial<{
    name: FieldOptions;
    website: FieldOptions;
    email: FieldOptions;
    phone: FieldOptions;
    geographicAddress: FieldOptions;
    nationalIdentification: FieldOptions & {
        nationalIdentifierType: NationalIdentifierTypeFieldOptions;
    };
    dateOfBirth: FieldOptions;
    placeOfBirth: FieldOptions;
    countryOfResidence: 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[];
};

/**
 * 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;
};

/** Represents a natural person's name identifier */
declare interface NaturalPersonNameId {
    /** This may be the family name, maiden name, or married name */
    primaryIdentifier: string;
    /** These may be forenames, given names, initials, or other secondary names */
    secondaryIdentifier?: string;
    /** The nature of the name specified */
    naturalPersonNameIdentifierType: NaturalPersonNameTypeCode_2;
}

declare type NaturalPersonNameIDV2 = {
    primaryIdentifier?: string;
    secondaryIdentifier?: string;
    naturalPersonNameIdentifierType?: NaturalPersonNameTypeCode;
};

/**
 * Natural Person Name Type Code
 * Specifies the type of name for a natural person
 *
 * @public
 */
declare type NaturalPersonNameTypeCode = 'ALIA' | 'BIRT' | 'MAID' | 'LEGL' | 'MISC';

/**
 * IVMS101 Core Types
 * Shared type definitions used by both IVMS101.2020 and IVMS101.2023 versions
 */

/** Codes representing the nature of a natural person's name */
declare type NaturalPersonNameTypeCode_2 = "ALIA" | "BIRT" | "MAID" | "LEGL" | "MISC";

declare type NaturalPersonNameV2 = Omit<NaturalPersonName, 'nameIdentifier'> & {
    nameIdentifier?: NaturalPersonNameIDV2[];
};

declare type NaturalPersonNationalIdentifierTypeCode = Omit<NationalIdentifierTypeCode_2, "LEIX" | "RAID">;

declare type NaturalPersonV2 = Omit<NaturalPerson_2, 'name'> & {
    name: NaturalPersonNameV2;
    customerIdentification?: string;
};

/**
 * 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 {
    private nodeUrl?;
    private authToken?;
    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);
    /**
     * 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
     * @param fetchToken - Supplies and refreshes the auth token
     * @returns A new EmbeddedComponent instance
     * @internal
     */
    createComponent<V, O, R = TransactionResponse<V>>(path: string, value: Partial<V>, options?: O, callbacks?: CallbackOptions, fetchToken?: () => Promise<string>): EmbeddedComponent<V, O, 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<Withdrawal, TransactionOptions, TransactionResponse<Withdrawal>>;
    /**
     * 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, TransactionResponse<ConnectionRequest>>;
    /**
     * 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, TransactionResponse<DepositRequest>>;
    /**
     * Creates an invoice reader component for extracting TAIP-16 invoice data from PDF invoices
     *
     * The component provides a PDF drag-and-drop upload UI. On upload, the PDF is
     * parsed and the extracted invoice data is returned. On completion,
     * the response contains the TAIP-16 invoice data.
     *
     * @returns A new EmbeddedComponent instance for invoice reader creation
     * @public
     */
    createInvoiceReader(): EmbeddedComponent<InvoiceReaderResponse, Record<string, never>, TransactionResponse<InvoiceReaderResponse>>;
    /**
     * Creates a deposit assist component
     *
     * @param value - Partial deposit transaction data
     * @param options - Optional transaction options
     * @param callbacks - Optional callback configuration
     * @returns A new EmbeddedComponent instance for deposit assistance
     * @public
     */
    createDepositAssist(value: Partial<Deposit>, options?: TransactionOptions, callbacks?: CallbackOptions): EmbeddedComponent<Deposit, TransactionOptions, TransactionResponse<Deposit>>;
}
export default Notabene;

/**
 * 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
 *
 * @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;
}

/**
 * Order Reference
 * Reference to a related order
 */
declare interface OrderReference {
    /**
     * Order identifier
     */
    id: string;
    /**
     * Date when the order was issued
     * ISO 8601 date format (YYYY-MM-DD)
     */
    issueDate?: string;
}

/**
 * Organization Interface
 * Represents a legal entity (company, institution, merchant) in TAP transactions.
 * Supports both schema.org/Organization properties and IVMS101 identity data for compliance.
 *
 * Organizations typically have less privacy concerns than natural persons, making direct
 * inclusion of IVMS101 data more common for transparency and compliance purposes.
 *
 * @example
 * ```typescript
 * // Basic organization with schema.org properties
 * const basicOrg: Organization = {
 *   "@id": "did:web:example.com",
 *   "@type": "https://schema.org/Organization",
 *   name: "Example Corp",
 *   url: "https://example.com",
 *   email: "contact@example.com"
 * };
 *
 * // VASP with full compliance data
 * const vasp: Organization = {
 *   "@id": "did:web:vasp.example.com",
 *   "@type": "https://schema.org/Organization",
 *   name: "Example Virtual Asset Service Provider",
 *   leiCode: "969500KN90DZLPGW6898",
 *   url: "https://vasp.example.com",
 *   logo: "https://vasp.example.com/logo.png",
 *   description: "Licensed Virtual Asset Service Provider",
 *   email: "compliance@vasp.example.com",
 *   telephone: "+1-555-123-4567",
 *   geographicAddress: [{
 *     addressType: "BIZZ",
 *     streetName: "456 Financial District",
 *     buildingNumber: "456",
 *     postCode: "10005",
 *     townName: "New York",
 *     country: "US"
 *   }],
 *   nationalIdentifier: {
 *     nationalIdentifier: "12-3456789",
 *     nationalIdentifierType: "TXID", // Tax ID
 *     countryOfIssue: "US"
 *   },
 *   countryOfRegistration: "US"
 * };
 *
 * // Merchant with MCC
 * const merchant: Organization = {
 *   "@id": "did:web:coffee.example.com",
 *   "@type": "https://schema.org/Organization",
 *   name: "Downtown Coffee Shop",
 *   mcc: "5812", // Restaurant
 *   url: "https://coffee.example.com",
 *   geographicAddress: [{
 *     addressType: "BIZZ",
 *     streetName: "123 Main Street",
 *     buildingNumber: "123",
 *     postCode: "12345",
 *     townName: "Anytown",
 *     country: "US"
 *   }]
 * };
 * ```
 *
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-6.md | TAIP-6: Party Identification}
 * @see {@link https://schema.org/Organization | schema.org/Organization}
 */
declare interface Organization extends Participant {
    "@type": "https://schema.org/Organization";
    /**
     * Legal Entity Identifier (LEI) code
     * 20-character alphanumeric code that uniquely identifies legal entities globally
     * Used to uniquely identify legal entities involved in financial transactions
     * @example "969500KN90DZLPGW6898"
     * @see {@link https://www.iso.org/standard/59771.html | ISO 17442}
     */
    leiCode?: LEICode;
    /**
     * Legal name of the organization
     * Can be a simple string or structured IVMS101 name identifiers
     * For regulated entities, IVMS101 format may be required for compliance
     * @example "Example Corporation Inc." // Simple string
     * @example [{ legalPersonName: "Example Corp", legalPersonNameIdentifierType: "LEGL" }] // IVMS101
     */
    name?: string | LegalPersonNameId[];
    /**
     * Customer identification string
     * Internal identifier used by the institution for this organization
     * @example "CORP-789012"
     */
    customerIdentification?: string;
    /**
     * National identification documents
     * Government-issued identifiers like tax ID, business registration number
     * @example { nationalIdentifier: "12-3456789", nationalIdentifierType: "TXID", countryOfIssue: "US" }
     */
    nationalIdentifier?: NationalIdentification_2<LegalEntityNationalIdentifierTypeCode>;
    /**
     * Merchant Category Code (ISO 18245)
     * Standard classification code for merchant types in payment transactions
     * Used primarily for merchants in payment requests
     *
     * @example "5411" // Grocery stores and supermarkets
     * @example "5812" // Restaurants
     * @example "5734" // Computer software stores
     * @example "6012" // Financial institutions
     * @see {@link https://www.iso.org/standard/33365.html | ISO 18245}
     */
    mcc?: string;
    /**
     * URL pointing to the organization's website
     * Based on schema.org/Organization
     * @example "https://example.vasp.com"
     * @example "https://merchant.example.com"
     */
    url?: string;
    /**
     * URL pointing to the organization's logo image
     * Based on schema.org/Organization
     * @example "https://example.vasp.com/logo.png"
     * @example "https://cdn.example.com/assets/logo.svg"
     */
    logo?: string;
    /**
     * Description of the organization
     * Based on schema.org/Organization
     * @example "Licensed Virtual Asset Service Provider"
     * @example "Online marketplace for digital assets and collectibles"
     * @example "Full-service financial institution"
     */
    description?: string;
    /**
     * Physical addresses of the organization
     * IVMS101 format addresses for regulatory compliance
     * Supports multiple address types (BIZZ for business, etc.)
     * @example [{ addressType: "BIZZ", streetName: "456 Business Ave", townName: "Finance City", country: "US" }]
     */
    geographicAddress?: Address_2[];
    /**
     * Country of registration/incorporation
     * ISO 3166-1 alpha-2 country code where the organization is legally registered
     * @example "US" // United States
     * @example "GB" // United Kingdom
     * @example "SG" // Singapore
     * @example "CH" // Switzerland
     */
    countryOfRegistration?: CountryCode;
}

/**
 * Originating VASP
 * Represents the VASP which initiates the VA transfer
 * @public
 */
declare type OriginatingVASP = {
    /** The originating VASP information */
    originatingVASP?: Person;
};

/**
 * 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 = {
    /**
     * Originator address. Optional because some assets have no knowable sender
     * (Lightning, Monero, shielded Zcash, batched exchange withdrawals).
     */
    source?: Source | Source[];
};

declare type OriginatorV2 = {
    originatorPerson: PersonV2[];
};

/**
 * 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 {
    type: ProofTypes;
    status: ProofStatus;
    /**
     * DID of the proven wallet. Absent on a screenshot or self-declaration proof
     * collected for a deposit without a `source`; the host attaches it if its
     * API requires one.
     */
    did?: DID;
    /**
     * CAIP-10 address of the proven wallet. Absent in the same case as `did`.
     */
    address?: CAIP10;
}

/**
 * Participant in a TAP transaction
 * Represents either a party (originator/beneficiary) or an agent in the transaction.
 * Can include verification methods and policies.
 *
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-5.md | TAIP-5: Agents}
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-6.md | TAIP-6: Party Identification}
 */
declare interface Participant {
    /**
     * Unique identifier for the participant
     * Can be either a DID or an IRI
     */
    "@id": DID_2 | IRI;
    "@context"?: string | string[];
    "@type"?: string | string[];
    /**
     * Contact email address
     * Based on schema.org/Organization and schema.org/Person
     * @example "compliance@example.vasp.com"
     */
    email?: string;
    /**
     * Contact telephone number
     * Based on schema.org/Organization and schema.org/Person
     * @example "+1-555-123-4567"
     */
    telephone?: string;
}

declare type Party = Person_2 | Organization;

declare type PartyType = "originator" | "beneficiary" | "customer" | "merchant" | "principal";

/**
 * 6.7
 * Data describing the contents of the payload.
 */
declare interface PayloadMetadata {
    /** The method used to map from a national system of writing to Latin script. */
    transliterationMethod?: TransliterationMethodCode[];
    /** The version of IVMS 101 to which the payload complies. */
    payloadVersion: PayloadVersionCode;
}

/**
 * The version of IVMS 101 to which the payload complies.
 */
declare enum PayloadVersionCode {
    /** Published May 2020 */
    V101 = "101",
    /** Published August 2023 */
    V101_2023 = "101.2023"
}

/**
 * Person
 * Represents either a natural person or a legal person
 * @public
 */
declare type Person = {
    /** Natural person information */
    naturalPerson?: NaturalPerson_2;
    /** Legal person information */
    legalPerson?: LegalPerson_2;
};

/**
 * Person Interface
 * Represents a natural person (individual) in TAP transactions.
 * Supports both schema.org/Person properties and IVMS101 identity data for compliance.
 *
 * **Privacy Considerations**: For natural person information, consider using selective disclosure
 * (TAIP-8) to protect sensitive data, especially when including IVMS101 fields like national
 * identifiers and detailed addresses.
 *
 * @example
 * ```typescript
 * // Basic person with schema.org properties
 * const basicPerson: Person = {
 *   "@id": "did:example:alice",
 *   "@type": "https://schema.org/Person",
 *   name: "Alice Johnson",
 *   email: "alice@example.com"
 * };
 *
 * // Person with IVMS101 compliance data
 * const compliancePerson: Person = {
 *   "@id": "did:example:bob",
 *   "@type": "https://schema.org/Person",
 *   name: [{
 *     primaryIdentifier: "Robert",
 *     secondaryIdentifier: "Smith",
 *     nameIdentifierType: "LEGL"
 *   }],
 *   geographicAddress: [{
 *     addressType: "HOME",
 *     streetName: "123 Main Street",
 *     buildingNumber: "123",
 *     postCode: "12345",
 *     townName: "Example City",
 *     country: "US"
 *   }],
 *   nationalIdentifier: {
 *     nationalIdentifier: "123-45-6789",
 *     nationalIdentifierType: "ARNU", // Social Security Number
 *     countryOfIssue: "US"
 *   },
 *   dateAndPlaceOfBirth: {
 *     dateOfBirth: "1990-01-15",
 *     placeOfBirth: "New York, NY, US"
 *   },
 *   countryOfResidence: "US"
 * };
 * ```
 *
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-6.md | TAIP-6: Party Identification}
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-8.md | TAIP-8: Selective Disclosure}
 */
declare interface Person_2 extends Participant {
    "@type": "https://schema.org/Person";
    /**
     * SHA-256 hash of the normalized participant name
     * Used for privacy-preserving name matching per TAIP-12
     * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-12.md | TAIP-12: Privacy-Preserving Name Matching}
     */
    nameHash?: string;
    /**
     * Customer identification string
     * Internal identifier used by the institution for this person
     * @example "CUST-123456"
     */
    customerIdentification?: string;
    /**
     * Person's name
     * Can be a simple string or structured IVMS101 name identifiers
     * For compliance use cases, IVMS101 format provides more detailed name structure
     * @example "Alice Johnson" // Simple string
     * @example [{ primaryIdentifier: "Alice", secondaryIdentifier: "Johnson", nameIdentifierType: "LEGL" }] // IVMS101
     */
    name?: string | NaturalPersonNameId[];
    /**
     * Geographic addresses associated with the person
     * IVMS101 format addresses for travel rule compliance
     * Supports multiple address types (HOME, BIZZ, etc.)
     * @example [{ addressType: "HOME", streetName: "123 Main St", townName: "City", country: "US" }]
     */
    geographicAddress?: Address_2[];
    /**
     * National identification documents
     * Government-issued identifiers like passport, SSN, driver's license
     * **Privacy**: Consider selective disclosure for sensitive ID information
     * @example { nationalIdentifier: "123-45-6789", nationalIdentifierType: "ARNU", countryOfIssue: "US" }
     */
    nationalIdentifier?: NationalIdentification_2<NaturalPersonNationalIdentifierTypeCode>;
    /**
     * Date and place of birth information
     * Used for identity verification and compliance
     * **Privacy**: Highly sensitive data - recommend selective disclosure
     */
    dateAndPlaceOfBirth?: {
        /** Date of birth in ISO 8601 format (YYYY-MM-DD) */
        dateOfBirth: string;
        /** Place of birth (city, state/province, country) */
        placeOfBirth: string;
    };
    /**
     * Country of residence
     * ISO 3166-1 alpha-2 country code where the person resides
     * @example "US"
     * @example "CA"
     * @example "GB"
     */
    countryOfResidence?: CountryCode;
}

/**
 * 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",
    SELF = "self"
}

declare type PersonV2 = Omit<Person, 'naturalPerson'> & {
    naturalPerson?: NaturalPersonV2;
    accountNumber?: string[];
};

/**
 * Policy type definition
 * Union type of all possible policy types in TAP.
 */
declare type Policies = RequireAuthorization | RequirePresentation | RequireRelationshipConfirmation | RequirePurpose;

/**
 * Base interface for all TAP policy types.
 * Policies define requirements and constraints that must be satisfied during a transaction.
 * Each specific policy type extends this base interface with its own requirements.
 *
 * @template T - The specific policy type identifier (e.g. "RequireAuthorization", "RequirePresentation")
 *
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-7.md | TAIP-7: Policies}
 */
declare interface Policy<T extends string> extends JsonLdObject<T> {
    /** The type identifier for this policy */
    "@type": T;
    /**
     * Optional DID of the party or agent required to fulfill this policy
     * Can be a single DID or an array of DIDs
     */
    from?: DID_2 | IRI;
    /**
     * Optional role of the party required to fulfill this policy
     * E.g. 'SettlementAddress', 'SourceAddress', or 'CustodialService'
     */
    fromRole?: AgentRoles;
    /**
     * Optional agent representing a party required to fulfill this policy
     * E.g. 'originator' or 'beneficiary' in TAIP-3
     */
    fromAgent?: PartyType;
    /**
     * Optional human-readable description of the policy's purpose
     * Used to explain why this requirement exists
     */
    purpose?: string;
}

/**
 * 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 {
    PENDING = "pending",// Verification is pending
    FAILED = "rejected",// Rejected
    FLAGGED = "flagged",// Flagged for manual review
    VERIFIED = "verified"
}

/**
 * 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)
 * - SIWX: Sign-In with X message signature
 * - SOL_SIWX: Sign-In with Solana message signature (SIWE for Solana)
 * - EIP712: Ethereum typed data signature following EIP-712 standard
 * - BIP137: Bitcoin message signature following BIP-137
 * - BIP322: Bitcoin message signature following BIP-322
 * - TIP191: Tron message signing
 * - ED25519: Ed25519 signature (used in Solana)
 * - XRP_ED25519: Ed25519 signature (used in XRP)
 * - XLM_ED25519: Ed25519 signature (used in Stellar)
 * - MicroTransfer: Proof via small blockchain transaction
 * - Screenshot: Image proof of ownership/access
 * - CIP8: Cardano message signing standard (CIP-8)
 *
 * @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",
    SIWE = "siwe",
    SIWX = "siwx",
    SOL_SIWX = "sol-siwx",
    EIP191 = "eip-191",
    EIP712 = "eip-712",
    EIP1271 = "eip-1271",
    BIP137 = "bip-137",
    BIP322 = "bip-322",
    TIP191 = "tip-191",
    ED25519 = "ed25519",
    XRP_ED25519 = "xrp-ed25519",
    XLM_ED25519 = "xlm-ed25519",
    CIP8 = "cip-8",
    COSMOS = "cosmos-ecdsa",
    MicroTransfer = "microtransfer",
    Screenshot = "screenshot",
    Connect = "connect",
    CONCORDIUM = "concordium"
}

/**
 * Represents a ready component message
 * @public
 */
export declare type Ready = {
    type: CMType.READY;
};

declare interface Refreshable {
    refreshSource?: RefreshSource;
}

export declare interface RefreshSource {
    url: URI;
    key: string;
    /**
     * The connection id (also embedded in `url`). Exposed directly so consumers can
     * correlate a Counterparty Assist webhook event (whose `payload.id` is this id)
     * without parsing it out of the url.
     */
    id: string;
}

/**
 * Message type for delivering a refreshed delegate token to a component
 *
 * @remarks
 * Sent from host to component when the SDK has fetched a new token, so the
 * component can keep operating without being reloaded.
 *
 * @see {@link HMType} For message type constants
 * @see {@link HostMessage} For full host message type union
 * @public
 */
export declare type RefreshToken = {
    type: HMType.TOKEN;
    token: string;
};

declare type RequestID = UUID;

/**
 * Policy requiring authorization before proceeding
 * Used to ensure specific agents authorize a transaction.
 *
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-7.md | TAIP-7: Policies}
 */
declare interface RequireAuthorization extends Policy<"RequireAuthorization"> {
}

/**
 * Policy requiring presentation of verifiable credentials
 * Used to request specific verifiable credentials from participants.
 *
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-7.md | TAIP-7: Policies}
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-8.md | TAIP-8: Verifiable Credentials}
 */
declare interface RequirePresentation extends Policy<"RequirePresentation"> {
    /**
     * Optional DID of the party the presentation is about
     * Used when requesting credentials about a specific party
     */
    aboutParty?: DID_2 | IRI;
    /**
     * Optional DID of the agent the presentation is about
     * Used when requesting credentials about a specific agent
     */
    aboutAgent?: DID_2 | IRI;
    /**
     * Presentation Exchange definition
     * Specifies the required credentials and constraints
     */
    presentationDefinition: string;
    /**
     * Optional credential type shorthand
     * Simplified way to request a specific credential type
     */
    credentialType?: string;
}

/**
 * Policy requiring purpose codes for transactions
 * Used to enforce the inclusion of ISO 20022 purpose codes.
 *
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-13.md | TAIP-13: Purpose Codes}
 */
declare interface RequirePurpose extends Policy<"RequirePurpose"> {
    /**
     * Required purpose code fields
     * Specifies which purpose code types must be included
     */
    required: Array<"purpose" | "categoryPurpose">;
}

/**
 * Policy requiring relationship confirmation
 * Used to verify control of addresses and relationships between parties.
 *
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-7.md | TAIP-7: Policies}
 * @see {@link https://github.com/TransactionAuthorizationProtocol/TAIPs/blob/main/TAIPs/taip-9.md | TAIP-9: Proof of Relationship}
 */
declare interface RequireRelationshipConfirmation extends Policy<"RequireRelationshipConfirmation"> {
    /**
     * Required nonce for signature
     * Prevents replay attacks
     */
    nonce: string;
}

/**
 * Represents a resize request component message. This is handled by the library.
 * @internal
 */
export declare type ResizeRequest = {
    type: CMType.RESIZE;
    height: number;
};

declare interface ResponseToIVMS101RequestConfig extends BaseRequestConfig {
    originator?: OriginatorV2;
    beneficiary?: BeneficiaryV2;
}

declare interface ResponseToTxCreateRequestConfig extends BaseRequestConfig {
    referenceId?: string;
    settlementAddress?: string;
}

export declare type ResponseToTxRequestConfig = ResponseToTxCreateRequestConfig & ResponseToIVMS101RequestConfig;

/**
 * Ownership Proof using Screenshot
 * @public
 */
export declare interface ScreenshotProof extends OwnershipProof {
    type: ProofTypes.Screenshot;
    url: string;
}

/**
 * Options that can be placed in either the main or fallback sections of the agent selection step.
 *
 * @remarks
 * Combines proof types from {@link ProofTypes} with additional UI-specific options:
 * - `ProofTypes.SelfDeclaration` — ownership proof via self-declaration
 * - `ProofTypes.Screenshot` — ownership proof via screenshot upload
 * - `ProofTypes.MicroTransfer` — ownership proof via micro-transfer
 * - `'signature'` — wallet connection for ownership proof via signature
 * - `'manual-signing'` — ownership proof via manual message signing
 * - `'add-vasp'` — manually add an unlisted exchange/VASP (hosted flow)
 * - `'contact-support'` — show a contact support button
 *
 * Options are automatically filtered by flow (e.g. `add-vasp` is ignored in self-hosted).
 * Including an option implicitly enables that capability.
 *
 * @public
 */
export declare type SectionOption = 'self-declaration' | 'screenshot' | 'microtransfer' | 'signature' | 'manual-signing' | 'add-vasp' | 'contact-support';

/**
 * 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.EIP191 | ProofTypes.EIP712 | ProofTypes.EIP1271 | ProofTypes.BIP137 | ProofTypes.BIP322 | ProofTypes.ED25519 | ProofTypes.TIP191 | ProofTypes.SIWX | ProofTypes.SOL_SIWX | ProofTypes.SIWE | ProofTypes.CIP8 | ProofTypes.XRP_ED25519 | ProofTypes.CONCORDIUM | ProofTypes.XLM_ED25519 | ProofTypes.COSMOS;
    proof: string;
    attestation: string;
    wallet_provider: string;
    xpub?: string;
    chainSpecificData?: {
        cardanoCoseKey?: string;
    } | SolanaMetadata | CosmosMetadata;
}

/**
 * Input for SIWX message signing
 * Every SIWX message must include the following fields:
 * - domain
 * - address
 * - statement
 * - uri
 * - version
 * - chainId
 *
 * Optional fields:
 * - nonce
 * - issuedAt
 * - expirationTime
 * - notBefore
 * - requestId
 * - resources
 *
 * @public
 */
export declare interface SIWXInput {
    domain: string;
    address: string;
    statement?: string;
    uri?: string;
    version?: string;
    chainId?: string;
    nonce?: string;
    issuedAt?: string;
    expirationTime?: string;
    notBefore?: string;
    requestId?: string;
    resources?: readonly string[];
}

/**
 * Metadata for Solana SIWX ownership proofs
 * @remarks
 * - Includes the account public key and address
 * - Includes the signed message
 * - Includes the signature
 * - Includes the message
 *
 * @see {@link SignatureProof} For signature-based proofs
 * @public
 */
export declare interface SolanaMetadata {
    account: {
        address: string;
        publicKey: Uint8Array;
    };
    signedMessage: Uint8Array;
    signature: Uint8Array;
    message: SIWXInput;
}

/**
 * The source of a transaction
 * @public
 */
declare type Source = BlockchainAddress | CAIP10;

/**
 * The verification status of a transaction
 * @public
 */
export declare enum Status {
    EMPTY = "empty",
    VERIFY = "verify",
    PENDING = "pending",
    VERIFIED = "verified",
    BANNED = "banned"
}

/**
 * Tax Category
 * Represents a tax category with its rate and scheme
 */
declare interface TaxCategory {
    /**
     * Tax category identifier
     * Uses UBL Tax Category Code standard
     *
     * @example TaxCategoryCode.StandardRate
     * @example TaxCategoryCode.ZeroRated
     * @example TaxCategoryCode.ExemptFromTax
     */
    id: TaxCategoryCode;
    /**
     * Tax rate percentage
     *
     * @example 20.0 // 20% VAT
     * @example 0.0  // Zero rate
     */
    percent: number;
    /**
     * Tax scheme identifier
     * Uses UBL Tax Scheme Code standard
     *
     * @example TaxSchemeCode.ValueAddedTax
     * @example TaxSchemeCode.GoodsAndServicesTax
     * @example TaxSchemeCode.SalesTax
     */
    taxScheme: TaxSchemeCode | string;
}

/**
 * UBL Tax Category Code standard (UN/ECE 5305 Tax Category Code)
 * Based on UN/CEFACT and EU tax categories
 *
 * @see {@link http://docs.oasis-open.org/ubl/os-UBL-2.1/cl/gc/default/TaxCategory-2.1.gc | UBL Tax Category Codes}
 * @see {@link https://docs.peppol.eu/poacc/billing/3.0/codelist/UNCL5305/ | PEPPOL BIS 3.0 Tax Category Codes}
 */
declare enum TaxCategoryCode {
    StandardRate = "S",
    ZeroRated = "Z",
    ExemptFromTax = "E",
    VATReverseCharge = "AE",
    FreeExportItem = "G",
    OutsideScopeOfTax = "O",
    VATExemptIntraCommunity = "K",
    CanaryIslandsIndirectTax = "L",
    CeutaMelillaTax = "M",
    HigherRate = "H",
    LowerRate = "AA",
    TransferredVAT = "B",
    MixedTaxRate = "A",
    ExemptForResale = "AB",
    VATReverseChargeAlt = "AC",
    VATExemptIntraCommunityAlt = "AD",
    ExemptFromTaxDeprecated = "C",
    ExemptArticle309 = "D"
}

/**
 * UBL Tax Scheme Code standard (UN/ECE 5305 Tax Type Code)
 * Based on UN/CEFACT tax types
 *
 * @see {@link http://docs.oasis-open.org/ubl/os-UBL-2.1/cl/gc/default/TaxScheme-2.1.gc | UBL Tax Scheme Codes}
 */
declare enum TaxSchemeCode {
    ProfitTax = "AAA",
    CorporateIncomeTax = "AAB",
    PersonalIncomeTax = "AAC",
    SocialSecurityTax = "AAD",
    PropertyTax = "AAE",
    InheritanceTax = "AAF",
    GiftTax = "AAG",
    CapitalGainsTax = "AAH",
    WealthTax = "AAI",
    StampDuty = "AAJ",
    ConsumptionTax = "CST",
    CustomsDuty = "CUS",
    EnvironmentalTax = "ENV",
    ExciseTax = "EXC",
    ExportTax = "EXP",
    FreightTax = "FRT",
    GoodsAndServicesTax = "GST",
    ImportTax = "IMP",
    OtherTax = "OTH",
    SalesTax = "SAL",
    TurnoverTax = "TOT",
    ValueAddedTax = "VAT"
}

/**
 * Tax Subtotal
 * Breakdown of taxes by category
 */
declare interface TaxSubtotal {
    /**
     * Amount subject to this tax
     */
    taxableAmount: number;
    /**
     * Tax amount for this category
     */
    taxAmount: number;
    /**
     * Tax category information
     */
    taxCategory: TaxCategory;
}

/**
 * Tax Total
 * Aggregate tax information for the invoice
 */
declare interface TaxTotal {
    /**
     * Total tax amount for the invoice
     */
    taxAmount: number;
    /**
     * Breakdown of taxes by category
     */
    taxSubtotal?: TaxSubtotal[];
}

/**
 * The theme of the Notabene SDK
 * @public
 */
export declare type Theme = {
    mode: 'light' | 'dark';
    backgroundColor?: string;
    primaryColor?: string;
    primaryForeground?: string;
    secondaryColor?: string;
    secondaryForeground?: string;
    fontFamily?: string;
    logo?: string;
};

/**
 * 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 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 {
    transactionId?: string;
    agent: Agent;
    counterparty: Counterparty;
    asset: TransactionAsset;
    amountDecimal: string | number;
    proof?: OwnershipProof;
    assetPrice?: {
        price: number;
        currency: ISOCurrency;
    };
    account?: Account;
}

/**
 * The asset of a transaction either a Notabene asset, a CAIP-19 asset, or a DTI.
 * @public
 */
export declare type TransactionAsset = NotabeneAsset | CAIP19 | DTI;

export declare interface TransactionCreateRequestV2 {
    originator: {
        '@id': string;
    };
    beneficiary: {
        '@id': string;
    };
    asset: string;
    amount: string;
    agents: Agent_2[];
    ref: string;
}

export declare interface TransactionIVMS101Request {
    ivms101: {
        originator?: OriginatorV2;
        beneficiary?: BeneficiaryV2;
    };
}

/**
 * Configuration options for Transaction components
 * @public
 */
export declare interface TransactionOptions {
    /**
     * Explicit layout configuration for the agent selection step.
     * When provided, takes precedence over legacy fields (`proofs.fallbacks`, `vasps.addUnknown`).
     */
    agentSections?: AgentSections;
    proofs?: {
        reuseProof?: boolean;
        microTransfer?: {
            destination: BlockchainAddress;
            amountSubunits: string;
            requireHash?: boolean;
        };
        fallbacks?: ProofTypes[];
        deminimis?: ThresholdOptions;
    };
    jurisdiction?: string;
    allowedAgentTypes?: AgentType[];
    allowedCounterpartyTypes?: PersonType[];
    fields?: FieldTypes;
    vasps?: VASPOptions;
    /**
     * Sections of the component to leave out. Hiding `'header'` is useful when the
     * surrounding page already states what the user is being asked to do, so ours
     * would repeat or contradict it.
     */
    hide?: HideSection[];
    counterpartyAssist?: CounterpartyAssistConfig;
    contactSupport?: ContactSupportConfig;
    consent?: ConsentConfig;
    autoSubmit?: boolean;
    /**
     * Wallet connection behaviour.
     */
    wallets?: {
        /**
         * EXPERIMENTAL. No stability guarantee; may change or be removed in a minor release.
         *
         * Prefer a wallet's `https://` universal link over its custom scheme (for example
         * `metamask://`) when connecting a mobile wallet. Useful when embedding inside a mobile
         * in-app webview, which cannot launch another app on its own and so needs the host app
         * to handle every custom scheme it might encounter.
         *
         * Off by default. Has no effect for wallets whose registry entry declares no universal
         * link, which is most of them today. Where a wallet does declare one, this also changes
         * behaviour in an ordinary mobile browser, and a universal link can be worse there if
         * the wallet's Android app links are not verified.
         *
         * Behaviour therefore depends on the wallet and on your host app. Verify against the
         * wallets your users actually use before enabling this in production.
         *
         * @defaultValue false
         */
        experimentalPreferUniversalLinks?: boolean;
        /**
         * Restrict the mobile wallets offered over WalletConnect to this list.
         *
         * Useful when you only support a fixed set of wallets, for example because your app
         * allowlists their deep links, or because your compliance policy approves specific
         * wallets.
         *
         * Entries are WalletConnect Explorer wallet ids, 64-character hex strings. Wallet names
         * are not accepted, because the Explorer registry keys on these ids. Look them up in
         * Reown's Wallets List (https://docs.reown.com/cloud/wallets/wallet-list) or WalletGuide
         * (https://walletguide.walletconnect.network/).
         *
         * A wallet can have more than one id. Coinbase, Binance, OKX and Talisman each have two
         * Explorer listings, so list every id for a wallet or one of its listings will still be
         * offered.
         *
         * This restricts WalletConnect's own wallet list only. It does not restrict browser
         * extension wallets, does not affect hardware wallets, and does not control whether
         * WalletConnect is offered at all.
         *
         * Absent or empty means no restriction.
         *
         * @example
         * ```ts
         * // MetaMask and both Coinbase listings
         * allowedWalletConnectIds: [
         *   'c57ca95b47569778a828d19178114f4db188b89b763c899ba0be274e97267d96',
         *   'fd20dc426fb37566d803205b19bbc1d4096b248ac04548e3cfb6b3a38bd033aa',
         *   'd0ca99ff52b99abc48743dad0f7fc891e041be73574f7fac4afe5d4bb83845c8'
         * ]
         * ```
         */
        allowedWalletConnectIds?: string[];
        /**
         * Never offer these wallets in the component's wallet picker, whatever the user's
         * browser has installed.
         *
         * Useful when you don't want to present specific wallets, for example hardware wallets.
         * This only controls which connectors the component offers. It isn't a policy on
         * addresses: a user can still reach the same device another way, such as Ledger Live
         * over WalletConnect, or prove an address with a non-wallet proof type where you allow
         * one.
         *
         * Entries are {@link WalletId}s and are matched case-insensitively. Hardware wallets and
         * the WalletConnect card have fixed ids, listed in {@link KnownWalletId}. Browser extension
         * wallets are matched by the id the component discovers them under.
         *
         * Hiding `'wallet-connect'` removes the WalletConnect card entirely; to offer some
         * mobile wallets but not others, use `allowedWalletConnectIds` instead.
         *
         * Absent or empty means every discovered wallet is offered.
         *
         * @example
         * ```ts
         * // No hardware wallets
         * hidden: ['ledger-usb-wallet', 'ledger-bluetooth-wallet', 'trezor']
         * ```
         */
        hidden?: WalletId[];
    };
}

/**
 * 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
 * - txUpdate: 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 interface TransactionResponse<V> extends ComponentResponse {
    value: V;
    ivms101: IVMS101;
    proof?: OwnershipProof;
    txCreate?: V1Transaction;
    txUpdate?: V1Transaction;
}

export declare type TransactionType = 'withdraw' | 'deposit';

/**
 * 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[];
};

/**
 * 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

 * 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}`;

/**
 * UBL Unit of Measure Code standard
 * Based on UN/CEFACT code list
 *
 * @see {@link http://docs.oasis-open.org/ubl/os-UBL-2.1/cl/gc/default/UnitOfMeasureCode-2.1.gc | UBL Unit of Measure Codes}
 */
declare enum UnitCode {
    Kilogram = "KGM",
    Gram = "GRM",
    Milligram = "MGM",
    Tonne = "TNE",
    Liter = "LTR",
    Milliliter = "MLT",
    CubicMillimeter = "MMQ",
    CubicCentimeter = "CMQ",
    CubicDecimeter = "DMQ",
    CubicMeter = "MTQ",
    Millimeter = "MMT",
    Centimeter = "CMT",
    Decimeter = "DMT",
    Meter = "MTR",
    Kilometer = "KMT",
    SquareMeter = "MTK",
    Each = "EA",
    Piece = "PCE",
    NumberOfPairs = "NPR",
    Second = "SEC",
    Minute = "MIN",
    Hour = "HUR",
    Day = "DAY",
    Week = "WEE",
    Month = "MON",
    Year = "ANN",
    KilowattHour = "KWH",
    NumberOfArticles = "NAR"
}

/**
 * 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<T>;
    options?: O;
};

/**
 * A Uniform Resource Identifier
 * @remarks This type will be narrowed to `` `${string}:${string}` `` in the next major release.
 * @public
 */
declare type URI = string;

/**
 * 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;
};

/**
 * Transaction payload suitable for calling Notabene v1 tx/create
 * @public
 */
export declare type V1Transaction = {
    transactionAsset: V1Asset;
    transactionAmount: string;
    originatorEqualsBeneficiary?: boolean;
    originatorVASPdid: DID;
    beneficiaryVASPdid: DID;
    beneficiaryProof?: OwnershipProof;
    originatorProof?: OwnershipProof;
    originator?: Originator;
    beneficiary: Beneficiary;
    transactionId?: string;
};

/**
 * Validation error
 * @public
 */
export declare type ValidationError = {
    attribute: string;
    message: string;
};

/**
 * Sections in a WithdrawalAssist screen
 *
 * @deprecated Use {@link HideSection} instead. Members stay assignable to their
 * literals, so existing callers keep compiling.
 *
 * @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 {
    /**
     * A VASP is identified by its DID, so it is required here although `Agent`
     * leaves it optional for the self-hosted agent of a deposit without a `source`.
     */
    did: DID;
    lei?: LEI;
    logo?: URI;
    website?: URI;
    countryOfRegistration?: ISOCountryCode;
    jurisdictions?: string;
}

/**
 * Options controlling which VASPs are listed and searchable in the picker.
 *
 * Two mutually exclusive variants:
 *
 * - **V1** — `addUnknown`, `onlyActive`, `searchable` (filters by {@link VASPSearchControl} status).
 * - **V2** — `addUnknown`, `onlyActive`, `showTrustStatus` (filters by {@link VASPTrustStatus}).
 *
 * `searchable` (V1-only) cannot be combined with `showTrustStatus` (V2-only);
 * TypeScript will reject the mix at compile time. `addUnknown` and `onlyActive` are valid in both variants.
 *
 * @example V1
 * ```ts
 * { addUnknown: true, onlyActive: true, searchable: [VASPSearchControl.ALLOWED] }
 * ```
 *
 * @example V2
 * ```ts
 * { addUnknown: true, onlyActive: true, showTrustStatus: ['TRUSTED', 'NEW'] }
 * ```
 *
 * @public
 */
export declare type VASPOptions = {
    addUnknown?: boolean;
    onlyActive?: boolean;
    searchable?: VASPSearchControl[];
} | {
    searchable?: undefined;
    addUnknown?: boolean;
    onlyActive?: boolean;
    showTrustStatus?: VASPTrustStatus[];
};

/**
 * VASP Visibility Control representing allow/deny behaviour for VASP visibility
 *
 * @remarks
 * - ALLOWED: Include VASPs you have explicitly allowed in the Notabene Network
 * - PENDING: Include VASPs neither allowed nor denied
 * @public
 */
export declare enum VASPSearchControl {
    ALLOWED = "allowed",
    PENDING = "pending"
}

/**
 * Trust status assigned to a VASP in the Notabene network.
 *
 * Used by {@link VASPOptions.showTrustStatus} to filter which VASPs are listed in the picker.
 *
 * @public
 */
export declare type VASPTrustStatus = 'TRUSTED' | 'NEW' | 'FLAGGED' | 'BANNED';

/**
 * A wallet agent acting on behalf of the counterparty
 * @public
 */
export declare interface Wallet extends Agent {
    proof: OwnershipProof;
    wallet_connect_id?: string;
}

/**
 * A wallet id as the embedded component reports it, for use in
 * {@link TransactionOptions.wallets}.
 *
 * A {@link KnownWalletId}, or any id of a wallet the component discovers in the user's
 * browser. Browser extension wallets on EVM chains use their EIP-6963 reverse domain
 * name, for example `'io.metamask'` or `'com.coinbase.wallet'`. Wallets on other chains
 * use the chain namespace followed by the wallet's name in lower case, for example
 * `'solana-phantom'`, `'bitcoin-xverse'`, `'tron-tronlink'`, `'cardano-nami'`,
 * `'ripple-gemwallet'` or `'concordium-browser'`.
 *
 * @public
 */
export declare type WalletId = KnownWalletId | (string & {});

/**
 * Represents a warning component message
 * @param message - Warning message
 * @param description - Description of the warning message
 * @param identifier - Identifier code of the warning message
 * @public
 */
declare type Warning = {
    type: CMType.WARNING;
    message: string;
    description?: string;
    identifier?: WarningIdentifierCode;
};

/**
 * Identifier codes for warning messages
 * @public
 */
export declare enum WarningIdentifierCode {
    WALLET_ADDRESS_NOT_CONNECTED = "WALLET_ADDRESS_NOT_CONNECTED",
    WALLET_LOCKED = "WALLET_LOCKED",
    WALLET_UNREACHABLE = "WALLET_UNREACHABLE",
    JURISDICTIONAL_REQUIREMENTS_UNAVAILABLE = "JURISDICTIONAL_REQUIREMENTS_UNAVAILABLE",
    IDV_UNAVAILABLE = "IDV_UNAVAILABLE",
    ASSET_NOT_FOUND = "ASSET_NOT_FOUND"
}

/**
 * An object representing a withdrawal transaction
 * @public
 */
export declare interface Withdrawal extends BeneficiaryFields, Transaction, Refreshable {
}

export { }