@onekeyfe/hd-transport 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,2725 @@
+import * as ByteBuffer from 'bytebuffer';
+import * as protobuf from 'protobufjs/light';
+import { Root } from 'protobufjs/light';
+
+declare function parseConfigure(data: protobuf.INamespace): protobuf.Root;
+
+declare function buildOne(messages: Root, name: string, data: Record<string, unknown>): Buffer;
+
+declare function receiveOne(messages: Root, data: string): {
+    message: {
+        [key: string]: any;
+    };
+    type: string;
+};
+
+declare type OneKeyUsbDeviceInfo = {
+    path: string;
+};
+declare type OneKeyDeviceInfoWithSession = OneKeyUsbDeviceInfo & {
+    session?: string | null;
+    debugSession?: string | null;
+    debug: boolean;
+};
+declare type OneKeyMobileDeviceInfo = {
+    id: string;
+    name: string | null;
+};
+declare type OneKeyDeviceInfo = OneKeyDeviceInfoWithSession & OneKeyMobileDeviceInfo;
+declare type AcquireInput = {
+    path?: string;
+    previous?: string | null;
+    uuid?: string;
+};
+declare type MessageFromOneKey = {
+    type: string;
+    message: Record<string, any>;
+};
+declare type Transport = {
+    enumerate(): Promise<Array<OneKeyDeviceInfo>>;
+    listen(old?: Array<OneKeyDeviceInfo>): Promise<Array<OneKeyDeviceInfo>>;
+    acquire(input: AcquireInput): Promise<string>;
+    release(session: string, onclose: boolean): Promise<void>;
+    configure(signedData: JSON | string): Promise<void>;
+    call(session: string, name: string, data: Record<string, any>): Promise<MessageFromOneKey>;
+    post(session: string, name: string, data: Record<string, any>): Promise<void>;
+    read(session: string): Promise<MessageFromOneKey>;
+    init(): Promise<string>;
+    stop(): void;
+    configured: boolean;
+    version: string;
+    name: string;
+    activeName?: string;
+    requestDevice: () => Promise<void>;
+    requestNeeded: boolean;
+    isOutdated: boolean;
+};
+
+declare type UintType = string | number;
+declare type Empty = Record<string, never>;
+declare type BinanceGetAddress = {
+    address_n: number[];
+    show_display?: boolean;
+};
+declare type BinanceAddress = {
+    address: string;
+};
+declare type BinanceGetPublicKey = {
+    address_n: number[];
+    show_display?: boolean;
+};
+declare type BinancePublicKey = {
+    public_key: string;
+};
+declare type BinanceSignTx = {
+    address_n: number[];
+    msg_count: number;
+    account_number: number;
+    chain_id?: string;
+    memo?: string;
+    sequence: number;
+    source: number;
+};
+declare type BinanceTxRequest = Record<string, never>;
+declare type BinanceCoin = {
+    amount: UintType;
+    denom: string;
+};
+declare type BinanceInputOutput = {
+    address: string;
+    coins: BinanceCoin[];
+};
+declare type BinanceTransferMsg = {
+    inputs: BinanceInputOutput[];
+    outputs: BinanceInputOutput[];
+};
+declare enum BinanceOrderType {
+    OT_UNKNOWN = 0,
+    MARKET = 1,
+    LIMIT = 2,
+    OT_RESERVED = 3
+}
+declare enum BinanceOrderSide {
+    SIDE_UNKNOWN = 0,
+    BUY = 1,
+    SELL = 2
+}
+declare enum BinanceTimeInForce {
+    TIF_UNKNOWN = 0,
+    GTE = 1,
+    TIF_RESERVED = 2,
+    IOC = 3
+}
+declare type BinanceOrderMsg = {
+    id?: string;
+    ordertype: BinanceOrderType;
+    price: number;
+    quantity: number;
+    sender?: string;
+    side: BinanceOrderSide;
+    symbol?: string;
+    timeinforce: BinanceTimeInForce;
+};
+declare type BinanceCancelMsg = {
+    refid?: string;
+    sender?: string;
+    symbol?: string;
+};
+declare type BinanceSignedTx = {
+    signature: string;
+    public_key: string;
+};
+declare enum Enum_InputScriptType {
+    SPENDADDRESS = 0,
+    SPENDMULTISIG = 1,
+    EXTERNAL = 2,
+    SPENDWITNESS = 3,
+    SPENDP2SHWITNESS = 4,
+    SPENDTAPROOT = 5
+}
+declare type InputScriptType = keyof typeof Enum_InputScriptType;
+declare enum Enum_OutputScriptType {
+    PAYTOADDRESS = 0,
+    PAYTOSCRIPTHASH = 1,
+    PAYTOMULTISIG = 2,
+    PAYTOOPRETURN = 3,
+    PAYTOWITNESS = 4,
+    PAYTOP2SHWITNESS = 5,
+    PAYTOTAPROOT = 6
+}
+declare type OutputScriptType = keyof typeof Enum_OutputScriptType;
+declare enum DecredStakingSpendType {
+    SSGen = 0,
+    SSRTX = 1
+}
+declare enum AmountUnit {
+    BITCOIN = 0,
+    MILLIBITCOIN = 1,
+    MICROBITCOIN = 2,
+    SATOSHI = 3
+}
+declare type HDNodeType = {
+    depth: number;
+    fingerprint: number;
+    child_num: number;
+    chain_code: string;
+    private_key?: string;
+    public_key: string;
+};
+declare type HDNodePathType = {
+    node: HDNodeType | string;
+    address_n: number[];
+};
+declare type MultisigRedeemScriptType = {
+    pubkeys: HDNodePathType[];
+    signatures: string[];
+    m: number;
+    nodes?: HDNodeType[];
+    address_n?: number[];
+};
+declare type GetPublicKey = {
+    address_n: number[];
+    ecdsa_curve_name?: string;
+    show_display?: boolean;
+    coin_name?: string;
+    script_type?: InputScriptType;
+    ignore_xpub_magic?: boolean;
+};
+declare type PublicKey = {
+    node: HDNodeType;
+    xpub: string;
+    root_fingerprint?: number;
+};
+declare type GetAddress = {
+    address_n: number[];
+    coin_name?: string;
+    show_display?: boolean;
+    multisig?: MultisigRedeemScriptType;
+    script_type?: InputScriptType;
+    ignore_xpub_magic?: boolean;
+};
+declare type Address = {
+    address: string;
+    mac?: string;
+};
+declare type GetOwnershipId = {
+    address_n: number[];
+    coin_name?: string;
+    multisig?: MultisigRedeemScriptType;
+    script_type?: InputScriptType;
+};
+declare type OwnershipId = {
+    ownership_id: string;
+};
+declare type SignMessage = {
+    address_n: number[];
+    message: string;
+    coin_name?: string;
+    script_type?: InputScriptType;
+    no_script_type?: boolean;
+};
+declare type MessageSignature = {
+    address: string;
+    signature: string;
+};
+declare type VerifyMessage = {
+    address: string;
+    signature: string;
+    message: string;
+    coin_name?: string;
+};
+declare type SignTx = {
+    outputs_count: number;
+    inputs_count: number;
+    coin_name?: string;
+    version?: number;
+    lock_time?: number;
+    expiry?: number;
+    overwintered?: boolean;
+    version_group_id?: number;
+    timestamp?: number;
+    branch_id?: number;
+    amount_unit?: AmountUnit;
+    decred_staking_ticket?: boolean;
+};
+declare enum Enum_RequestType {
+    TXINPUT = 0,
+    TXOUTPUT = 1,
+    TXMETA = 2,
+    TXFINISHED = 3,
+    TXEXTRADATA = 4,
+    TXORIGINPUT = 5,
+    TXORIGOUTPUT = 6,
+    TXPAYMENTREQ = 7
+}
+declare type RequestType = keyof typeof Enum_RequestType;
+declare type TxRequestDetailsType = {
+    request_index: number;
+    tx_hash?: string;
+    extra_data_len?: number;
+    extra_data_offset?: number;
+};
+declare type TxRequestSerializedType = {
+    signature_index?: number;
+    signature?: string;
+    serialized_tx?: string;
+};
+declare type TxRequest = {
+    request_type: RequestType;
+    details: TxRequestDetailsType;
+    serialized?: TxRequestSerializedType;
+};
+declare type InternalInputScriptType = Exclude<InputScriptType, 'EXTERNAL'>;
+declare type CommonTxInputType = {
+    prev_hash: string;
+    prev_index: number;
+    amount: UintType;
+    sequence?: number;
+    multisig?: MultisigRedeemScriptType;
+    decred_tree?: number;
+    orig_hash?: string;
+    orig_index?: number;
+    decred_staking_spend?: DecredStakingSpendType;
+    script_pubkey?: string;
+    script_sig?: string;
+    witness?: string;
+    ownership_proof?: string;
+    commitment_data?: string;
+};
+declare type TxInputType = (CommonTxInputType & {
+    address_n: number[];
+    script_type?: InternalInputScriptType;
+}) | (CommonTxInputType & {
+    address_n?: typeof undefined;
+    script_type: 'EXTERNAL';
+    script_pubkey: string;
+});
+declare type TxInput = TxInputType;
+declare type TxOutputBinType = {
+    amount: UintType;
+    script_pubkey: string;
+    decred_script_version?: number;
+};
+declare type ChangeOutputScriptType = Exclude<OutputScriptType, 'PAYTOOPRETURN'>;
+declare type TxOutputType = {
+    address: string;
+    address_n?: typeof undefined;
+    script_type: 'PAYTOADDRESS';
+    amount: UintType;
+    multisig?: MultisigRedeemScriptType;
+    orig_hash?: string;
+    orig_index?: number;
+    payment_req_index?: number;
+} | {
+    address?: typeof undefined;
+    address_n: number[];
+    script_type: ChangeOutputScriptType;
+    amount: UintType;
+    multisig?: MultisigRedeemScriptType;
+    orig_hash?: string;
+    orig_index?: number;
+    payment_req_index?: number;
+} | {
+    address?: typeof undefined;
+    address_n?: typeof undefined;
+    amount: '0';
+    op_return_data: string;
+    script_type: 'PAYTOOPRETURN';
+    orig_hash?: string;
+    orig_index?: number;
+    payment_req_index?: number;
+};
+declare type TxOutput = TxOutputType;
+declare type PrevTx = {
+    version: number;
+    lock_time: number;
+    inputs_count: number;
+    outputs_count: number;
+    extra_data_len?: number;
+    expiry?: number;
+    version_group_id?: number;
+    timestamp?: number;
+    branch_id?: number;
+};
+declare type PrevInput = {
+    prev_hash: string;
+    prev_index: number;
+    script_sig: string;
+    sequence: number;
+    decred_tree?: number;
+};
+declare type PrevOutput = {
+    amount: UintType;
+    script_pubkey: string;
+    decred_script_version?: number;
+};
+declare type TextMemo = {
+    text: string;
+};
+declare type RefundMemo = {
+    address: string;
+    mac: string;
+};
+declare type CoinPurchaseMemo = {
+    coin_type: number;
+    amount: UintType;
+    address: string;
+    mac: string;
+};
+declare type PaymentRequestMemo = {
+    text_memo?: TextMemo;
+    refund_memo?: RefundMemo;
+    coin_purchase_memo?: CoinPurchaseMemo;
+};
+declare type TxAckPaymentRequest = {
+    nonce?: string;
+    recipient_name: string;
+    memos?: PaymentRequestMemo[];
+    amount?: UintType;
+    signature: string;
+};
+declare type TxAckResponse = {
+    inputs: Array<TxInputType | PrevInput>;
+} | {
+    bin_outputs: TxOutputBinType[];
+} | {
+    outputs: TxOutputType[];
+} | {
+    extra_data: string;
+} | {
+    version?: number;
+    lock_time?: number;
+    inputs_cnt: number;
+    outputs_cnt: number;
+    extra_data?: string;
+    extra_data_len?: number;
+    timestamp?: number;
+    version_group_id?: number;
+    expiry?: number;
+    branch_id?: number;
+};
+declare type TxAck = {
+    tx: TxAckResponse;
+};
+declare type TxAckInputWrapper = {
+    input: TxInput;
+};
+declare type TxAckInput = {
+    tx: TxAckInputWrapper;
+};
+declare type TxAckOutputWrapper = {
+    output: TxOutput;
+};
+declare type TxAckOutput = {
+    tx: TxAckOutputWrapper;
+};
+declare type TxAckPrevMeta = {
+    tx: PrevTx;
+};
+declare type TxAckPrevInputWrapper = {
+    input: PrevInput;
+};
+declare type TxAckPrevInput = {
+    tx: TxAckPrevInputWrapper;
+};
+declare type TxAckPrevOutputWrapper = {
+    output: PrevOutput;
+};
+declare type TxAckPrevOutput = {
+    tx: TxAckPrevOutputWrapper;
+};
+declare type TxAckPrevExtraDataWrapper = {
+    extra_data_chunk: string;
+};
+declare type TxAckPrevExtraData = {
+    tx: TxAckPrevExtraDataWrapper;
+};
+declare type GetOwnershipProof = {
+    address_n: number[];
+    coin_name?: string;
+    script_type?: InputScriptType;
+    multisig?: MultisigRedeemScriptType;
+    user_confirmation?: boolean;
+    ownership_ids?: string[];
+    commitment_data?: string;
+};
+declare type OwnershipProof = {
+    ownership_proof: string;
+    signature: string;
+};
+declare type AuthorizeCoinJoin = {
+    coordinator: string;
+    max_rounds: number;
+    max_coordinator_fee_rate: number;
+    max_fee_per_kvbyte: number;
+    address_n: number[];
+    coin_name?: string;
+    script_type?: InputScriptType;
+    amount_unit?: AmountUnit;
+};
+declare type FirmwareErase = {
+    length?: number;
+};
+declare type FirmwareRequest = {
+    offset?: number;
+    length?: number;
+};
+declare type FirmwareUpload = {
+    payload: Buffer | ArrayBuffer;
+    hash?: string;
+};
+declare type SelfTest = {
+    payload?: string;
+};
+declare enum CardanoDerivationType {
+    LEDGER = 0,
+    ICARUS = 1,
+    ICARUS_TREZOR = 2
+}
+declare enum CardanoAddressType {
+    BASE = 0,
+    BASE_SCRIPT_KEY = 1,
+    BASE_KEY_SCRIPT = 2,
+    BASE_SCRIPT_SCRIPT = 3,
+    POINTER = 4,
+    POINTER_SCRIPT = 5,
+    ENTERPRISE = 6,
+    ENTERPRISE_SCRIPT = 7,
+    BYRON = 8,
+    REWARD = 14,
+    REWARD_SCRIPT = 15
+}
+declare enum CardanoNativeScriptType {
+    PUB_KEY = 0,
+    ALL = 1,
+    ANY = 2,
+    N_OF_K = 3,
+    INVALID_BEFORE = 4,
+    INVALID_HEREAFTER = 5
+}
+declare enum CardanoNativeScriptHashDisplayFormat {
+    HIDE = 0,
+    BECH32 = 1,
+    POLICY_ID = 2
+}
+declare enum CardanoCertificateType {
+    STAKE_REGISTRATION = 0,
+    STAKE_DEREGISTRATION = 1,
+    STAKE_DELEGATION = 2,
+    STAKE_POOL_REGISTRATION = 3
+}
+declare enum CardanoPoolRelayType {
+    SINGLE_HOST_IP = 0,
+    SINGLE_HOST_NAME = 1,
+    MULTIPLE_HOST_NAME = 2
+}
+declare enum CardanoTxAuxiliaryDataSupplementType {
+    NONE = 0,
+    CATALYST_REGISTRATION_SIGNATURE = 1
+}
+declare enum CardanoTxSigningMode {
+    ORDINARY_TRANSACTION = 0,
+    POOL_REGISTRATION_AS_OWNER = 1,
+    MULTISIG_TRANSACTION = 2,
+    PLUTUS_TRANSACTION = 3
+}
+declare enum CardanoTxWitnessType {
+    BYRON_WITNESS = 0,
+    SHELLEY_WITNESS = 1
+}
+declare type CardanoBlockchainPointerType = {
+    block_index: number;
+    tx_index: number;
+    certificate_index: number;
+};
+declare type CardanoNativeScript = {
+    type: CardanoNativeScriptType;
+    scripts?: CardanoNativeScript[];
+    key_hash?: string;
+    key_path?: number[];
+    required_signatures_count?: number;
+    invalid_before?: UintType;
+    invalid_hereafter?: UintType;
+};
+declare type CardanoGetNativeScriptHash = {
+    script: CardanoNativeScript;
+    display_format: CardanoNativeScriptHashDisplayFormat;
+    derivation_type: CardanoDerivationType;
+};
+declare type CardanoNativeScriptHash = {
+    script_hash: string;
+};
+declare type CardanoAddressParametersType = {
+    address_type: CardanoAddressType;
+    address_n: number[];
+    address_n_staking: number[];
+    staking_key_hash?: string;
+    certificate_pointer?: CardanoBlockchainPointerType;
+    script_payment_hash?: string;
+    script_staking_hash?: string;
+};
+declare type CardanoGetAddress = {
+    show_display?: boolean;
+    protocol_magic: number;
+    network_id: number;
+    address_parameters: CardanoAddressParametersType;
+    derivation_type: CardanoDerivationType;
+};
+declare type CardanoAddress = {
+    address: string;
+};
+declare type CardanoGetPublicKey = {
+    address_n: number[];
+    show_display?: boolean;
+    derivation_type: CardanoDerivationType;
+};
+declare type CardanoPublicKey = {
+    xpub: string;
+    node: HDNodeType;
+};
+declare type CardanoSignTxInit = {
+    signing_mode: CardanoTxSigningMode;
+    protocol_magic: number;
+    network_id: number;
+    inputs_count: number;
+    outputs_count: number;
+    fee: UintType;
+    ttl?: UintType;
+    certificates_count: number;
+    withdrawals_count: number;
+    has_auxiliary_data: boolean;
+    validity_interval_start?: UintType;
+    witness_requests_count: number;
+    minting_asset_groups_count: number;
+    derivation_type: CardanoDerivationType;
+    include_network_id?: boolean;
+    script_data_hash?: string;
+    collateral_inputs_count: number;
+    required_signers_count: number;
+};
+declare type CardanoTxInput = {
+    prev_hash: string;
+    prev_index: number;
+};
+declare type CardanoTxOutput = {
+    address?: string;
+    address_parameters?: CardanoAddressParametersType;
+    amount: UintType;
+    asset_groups_count: number;
+    datum_hash?: string;
+};
+declare type CardanoAssetGroup = {
+    policy_id: string;
+    tokens_count: number;
+};
+declare type CardanoToken = {
+    asset_name_bytes: string;
+    amount?: UintType;
+    mint_amount?: UintType;
+};
+declare type CardanoPoolOwner = {
+    staking_key_path?: number[];
+    staking_key_hash?: string;
+};
+declare type CardanoPoolRelayParameters = {
+    type: CardanoPoolRelayType;
+    ipv4_address?: string;
+    ipv6_address?: string;
+    host_name?: string;
+    port?: number;
+};
+declare type CardanoPoolMetadataType = {
+    url: string;
+    hash: string;
+};
+declare type CardanoPoolParametersType = {
+    pool_id: string;
+    vrf_key_hash: string;
+    pledge: UintType;
+    cost: UintType;
+    margin_numerator: UintType;
+    margin_denominator: UintType;
+    reward_account: string;
+    owners: CardanoPoolOwner[];
+    relays: CardanoPoolRelayParameters[];
+    metadata?: CardanoPoolMetadataType;
+    owners_count: number;
+    relays_count: number;
+};
+declare type CardanoTxCertificate = {
+    type: CardanoCertificateType;
+    path?: number[];
+    pool?: string;
+    pool_parameters?: CardanoPoolParametersType;
+    script_hash?: string;
+    key_hash?: string;
+};
+declare type CardanoTxWithdrawal = {
+    path?: number[];
+    amount: UintType;
+    script_hash?: string;
+    key_hash?: string;
+};
+declare type CardanoCatalystRegistrationParametersType = {
+    voting_public_key: string;
+    staking_path: number[];
+    reward_address_parameters: CardanoAddressParametersType;
+    nonce: UintType;
+};
+declare type CardanoTxAuxiliaryData = {
+    catalyst_registration_parameters?: CardanoCatalystRegistrationParametersType;
+    hash?: string;
+};
+declare type CardanoTxMint = {
+    asset_groups_count: number;
+};
+declare type CardanoTxCollateralInput = {
+    prev_hash: string;
+    prev_index: number;
+};
+declare type CardanoTxRequiredSigner = {
+    key_hash?: string;
+    key_path?: number[];
+};
+declare type CardanoTxItemAck = Empty;
+declare type CardanoTxAuxiliaryDataSupplement = {
+    type: CardanoTxAuxiliaryDataSupplementType;
+    auxiliary_data_hash?: string;
+    catalyst_signature?: string;
+};
+declare type CardanoTxWitnessRequest = {
+    path: number[];
+};
+declare type CardanoTxWitnessResponse = {
+    type: CardanoTxWitnessType;
+    pub_key: string;
+    signature: string;
+    chain_code?: string;
+};
+declare type CardanoTxHostAck = Empty;
+declare type CardanoTxBodyHash = {
+    tx_hash: string;
+};
+declare type CardanoSignTxFinished = Empty;
+declare type CardanoTxInputType = {
+    address_n?: number[];
+    prev_hash: string;
+    prev_index: number;
+};
+declare type CardanoTokenType = {
+    asset_name_bytes: string;
+    amount: UintType;
+};
+declare type CardanoAssetGroupType = {
+    policy_id: string;
+    tokens: CardanoTokenType[];
+};
+declare type CardanoTxOutputType = {
+    address?: string;
+    amount: UintType;
+    address_parameters?: CardanoAddressParametersType;
+    token_bundle: CardanoAssetGroupType[];
+};
+declare type CardanoPoolOwnerType = {
+    staking_key_path?: number[];
+    staking_key_hash?: string;
+};
+declare type CardanoPoolRelayParametersType = {
+    type: CardanoPoolRelayType;
+    ipv4_address?: string;
+    ipv6_address?: string;
+    host_name?: string;
+    port?: number;
+};
+declare type CardanoTxCertificateType = {
+    type: CardanoCertificateType;
+    path?: number[];
+    pool?: string;
+    pool_parameters?: CardanoPoolParametersType;
+};
+declare type CardanoTxWithdrawalType = {
+    path: number[];
+    amount: UintType;
+};
+declare type CardanoTxAuxiliaryDataType = {
+    blob?: string;
+    catalyst_registration_parameters?: CardanoCatalystRegistrationParametersType;
+};
+declare type CardanoSignTx = {
+    inputs: CardanoTxInputType[];
+    outputs: CardanoTxOutputType[];
+    protocol_magic: number;
+    fee: UintType;
+    ttl?: UintType;
+    network_id: number;
+    certificates: CardanoTxCertificateType[];
+    withdrawals: CardanoTxWithdrawalType[];
+    validity_interval_start?: UintType;
+    auxiliary_data?: CardanoTxAuxiliaryDataType;
+};
+declare type CardanoSignedTxChunk = {
+    signed_tx_chunk: string;
+};
+declare type CardanoSignedTxChunkAck = Empty;
+declare type CardanoSignedTx = {
+    tx_hash: string;
+    serialized_tx?: string;
+};
+declare type Success = {
+    message: string;
+};
+declare enum FailureType {
+    Failure_UnexpectedMessage = 1,
+    Failure_ButtonExpected = 2,
+    Failure_DataError = 3,
+    Failure_ActionCancelled = 4,
+    Failure_PinExpected = 5,
+    Failure_PinCancelled = 6,
+    Failure_PinInvalid = 7,
+    Failure_InvalidSignature = 8,
+    Failure_ProcessError = 9,
+    Failure_NotEnoughFunds = 10,
+    Failure_NotInitialized = 11,
+    Failure_PinMismatch = 12,
+    Failure_WipeCodeMismatch = 13,
+    Failure_InvalidSession = 14,
+    Failure_FirmwareError = 99
+}
+declare type Failure = {
+    code?: FailureType | string;
+    message?: string;
+};
+declare enum Enum_ButtonRequestType {
+    ButtonRequest_Other = 1,
+    ButtonRequest_FeeOverThreshold = 2,
+    ButtonRequest_ConfirmOutput = 3,
+    ButtonRequest_ResetDevice = 4,
+    ButtonRequest_ConfirmWord = 5,
+    ButtonRequest_WipeDevice = 6,
+    ButtonRequest_ProtectCall = 7,
+    ButtonRequest_SignTx = 8,
+    ButtonRequest_FirmwareCheck = 9,
+    ButtonRequest_Address = 10,
+    ButtonRequest_PublicKey = 11,
+    ButtonRequest_MnemonicWordCount = 12,
+    ButtonRequest_MnemonicInput = 13,
+    _Deprecated_ButtonRequest_PassphraseType = 14,
+    ButtonRequest_UnknownDerivationPath = 15,
+    ButtonRequest_RecoveryHomepage = 16,
+    ButtonRequest_Success = 17,
+    ButtonRequest_Warning = 18,
+    ButtonRequest_PassphraseEntry = 19,
+    ButtonRequest_PinEntry = 20
+}
+declare type ButtonRequestType = keyof typeof Enum_ButtonRequestType;
+declare type ButtonRequest = {
+    code?: ButtonRequestType;
+    pages?: number;
+};
+declare type ButtonAck = Empty;
+declare enum Enum_PinMatrixRequestType {
+    PinMatrixRequestType_Current = 1,
+    PinMatrixRequestType_NewFirst = 2,
+    PinMatrixRequestType_NewSecond = 3,
+    PinMatrixRequestType_WipeCodeFirst = 4,
+    PinMatrixRequestType_WipeCodeSecond = 5
+}
+declare type PinMatrixRequestType = keyof typeof Enum_PinMatrixRequestType;
+declare type PinMatrixRequest = {
+    type?: PinMatrixRequestType;
+};
+declare type PinMatrixAck = {
+    pin: string;
+};
+declare type PassphraseRequest = {
+    _on_device?: boolean;
+};
+declare type PassphraseAck = {
+    passphrase?: string;
+    _state?: string;
+    on_device?: boolean;
+};
+declare type Deprecated_PassphraseStateRequest = {
+    state?: string;
+};
+declare type Deprecated_PassphraseStateAck = Empty;
+declare type CipherKeyValue = {
+    address_n: number[];
+    key: string;
+    value: string;
+    encrypt?: boolean;
+    ask_on_encrypt?: boolean;
+    ask_on_decrypt?: boolean;
+    iv?: string;
+};
+declare type CipheredKeyValue = {
+    value: string;
+};
+declare type IdentityType = {
+    proto?: string;
+    user?: string;
+    host?: string;
+    port?: string;
+    path?: string;
+    index?: number;
+};
+declare type SignIdentity = {
+    identity: IdentityType;
+    challenge_hidden?: string;
+    challenge_visual?: string;
+    ecdsa_curve_name?: string;
+};
+declare type SignedIdentity = {
+    address: string;
+    public_key: string;
+    signature: string;
+};
+declare type GetECDHSessionKey = {
+    identity: IdentityType;
+    peer_public_key: string;
+    ecdsa_curve_name?: string;
+};
+declare type ECDHSessionKey = {
+    session_key: string;
+    public_key?: string;
+};
+declare enum DebugButton {
+    NO = 0,
+    YES = 1,
+    INFO = 2
+}
+declare type EosGetPublicKey = {
+    address_n: number[];
+    show_display?: boolean;
+};
+declare type EosPublicKey = {
+    wif_public_key: string;
+    raw_public_key: string;
+};
+declare type EosTxHeader = {
+    expiration: number;
+    ref_block_num: number;
+    ref_block_prefix: number;
+    max_net_usage_words: number;
+    max_cpu_usage_ms: number;
+    delay_sec: number;
+};
+declare type EosSignTx = {
+    address_n: number[];
+    chain_id: string;
+    header: EosTxHeader;
+    num_actions: number;
+};
+declare type EosTxActionRequest = {
+    data_size?: number;
+};
+declare type EosAsset = {
+    amount: UintType;
+    symbol: string;
+};
+declare type EosPermissionLevel = {
+    actor: string;
+    permission: string;
+};
+declare type EosAuthorizationKey = {
+    type?: number;
+    key: string;
+    address_n?: number[];
+    weight: number;
+};
+declare type EosAuthorizationAccount = {
+    account: EosPermissionLevel;
+    weight: number;
+};
+declare type EosAuthorizationWait = {
+    wait_sec: number;
+    weight: number;
+};
+declare type EosAuthorization = {
+    threshold: number;
+    keys: EosAuthorizationKey[];
+    accounts: EosAuthorizationAccount[];
+    waits: EosAuthorizationWait[];
+};
+declare type EosActionCommon = {
+    account: string;
+    name: string;
+    authorization: EosPermissionLevel[];
+};
+declare type EosActionTransfer = {
+    sender: string;
+    receiver: string;
+    quantity: EosAsset;
+    memo: string;
+};
+declare type EosActionDelegate = {
+    sender: string;
+    receiver: string;
+    net_quantity: EosAsset;
+    cpu_quantity: EosAsset;
+    transfer: boolean;
+};
+declare type EosActionUndelegate = {
+    sender: string;
+    receiver: string;
+    net_quantity: EosAsset;
+    cpu_quantity: EosAsset;
+};
+declare type EosActionRefund = {
+    owner: string;
+};
+declare type EosActionBuyRam = {
+    payer: string;
+    receiver: string;
+    quantity: EosAsset;
+};
+declare type EosActionBuyRamBytes = {
+    payer: string;
+    receiver: string;
+    bytes: number;
+};
+declare type EosActionSellRam = {
+    account: string;
+    bytes: number;
+};
+declare type EosActionVoteProducer = {
+    voter: string;
+    proxy: string;
+    producers: string[];
+};
+declare type EosActionUpdateAuth = {
+    account: string;
+    permission: string;
+    parent: string;
+    auth: EosAuthorization;
+};
+declare type EosActionDeleteAuth = {
+    account: string;
+    permission: string;
+};
+declare type EosActionLinkAuth = {
+    account: string;
+    code: string;
+    type: string;
+    requirement: string;
+};
+declare type EosActionUnlinkAuth = {
+    account: string;
+    code: string;
+    type: string;
+};
+declare type EosActionNewAccount = {
+    creator: string;
+    name: string;
+    owner: EosAuthorization;
+    active: EosAuthorization;
+};
+declare type EosActionUnknown = {
+    data_size: number;
+    data_chunk: string;
+};
+declare type EosTxActionAck = {
+    common: EosActionCommon;
+    transfer?: EosActionTransfer;
+    delegate?: EosActionDelegate;
+    undelegate?: EosActionUndelegate;
+    refund?: EosActionRefund;
+    buy_ram?: EosActionBuyRam;
+    buy_ram_bytes?: EosActionBuyRamBytes;
+    sell_ram?: EosActionSellRam;
+    vote_producer?: EosActionVoteProducer;
+    update_auth?: EosActionUpdateAuth;
+    delete_auth?: EosActionDeleteAuth;
+    link_auth?: EosActionLinkAuth;
+    unlink_auth?: EosActionUnlinkAuth;
+    new_account?: EosActionNewAccount;
+    unknown?: EosActionUnknown;
+};
+declare type EosSignedTx = {
+    signature: string;
+};
+declare type EthereumSignTypedData = {
+    address_n: number[];
+    primary_type: string;
+    metamask_v4_compat?: boolean;
+};
+declare type EthereumTypedDataStructRequest = {
+    name: string;
+};
+declare enum EthereumDataType {
+    UINT = 1,
+    INT = 2,
+    BYTES = 3,
+    STRING = 4,
+    BOOL = 5,
+    ADDRESS = 6,
+    ARRAY = 7,
+    STRUCT = 8
+}
+declare type EthereumFieldType = {
+    data_type: EthereumDataType;
+    size?: number;
+    entry_type?: EthereumFieldType;
+    struct_name?: string;
+};
+declare type EthereumStructMember = {
+    type: EthereumFieldType;
+    name: string;
+};
+declare type EthereumTypedDataStructAck = {
+    members: EthereumStructMember[];
+};
+declare type EthereumTypedDataValueRequest = {
+    member_path: number[];
+};
+declare type EthereumTypedDataValueAck = {
+    value: string;
+};
+declare type EthereumGetPublicKey = {
+    address_n: number[];
+    show_display?: boolean;
+};
+declare type EthereumPublicKey = {
+    node: HDNodeType;
+    xpub: string;
+};
+declare type EthereumGetAddress = {
+    address_n: number[];
+    show_display?: boolean;
+};
+declare type EthereumAddress = {
+    _old_address?: string;
+    address: string;
+};
+declare type EthereumSignTx = {
+    address_n: number[];
+    nonce?: string;
+    gas_price: string;
+    gas_limit: string;
+    to?: string;
+    value?: string;
+    data_initial_chunk?: string;
+    data_length?: number;
+    chain_id: number;
+    tx_type?: number;
+};
+declare type EthereumAccessList = {
+    address: string;
+    storage_keys: string[];
+};
+declare type EthereumSignTxEIP1559 = {
+    address_n: number[];
+    nonce: string;
+    max_gas_fee: string;
+    max_priority_fee: string;
+    gas_limit: string;
+    to?: string;
+    value: string;
+    data_initial_chunk?: string;
+    data_length: number;
+    chain_id: number;
+    access_list: EthereumAccessList[];
+};
+declare type EthereumTxRequest = {
+    data_length?: number;
+    signature_v?: number;
+    signature_r?: string;
+    signature_s?: string;
+};
+declare type EthereumTxAck = {
+    data_chunk: string;
+};
+declare type EthereumSignMessage = {
+    address_n: number[];
+    message: string;
+};
+declare type EthereumSignMessageEIP712 = {
+    address_n: number[];
+    domain_hash: string;
+    message_hash: string;
+};
+declare type EthereumMessageSignature = {
+    signature: string;
+    address: string;
+};
+declare type EthereumVerifyMessage = {
+    signature: string;
+    message: string;
+    address: string;
+};
+declare type EthereumSignTypedHash = {
+    address_n: number[];
+    domain_separator_hash: string;
+    message_hash?: string;
+};
+declare type EthereumTypedDataSignature = {
+    signature: string;
+    address: string;
+};
+declare enum Enum_BackupType {
+    Bip39 = 0,
+    Slip39_Basic = 1,
+    Slip39_Advanced = 2
+}
+declare type BackupType = keyof typeof Enum_BackupType;
+declare enum Enum_SafetyCheckLevel {
+    Strict = 0,
+    PromptAlways = 1,
+    PromptTemporarily = 2
+}
+declare type SafetyCheckLevel = keyof typeof Enum_SafetyCheckLevel;
+declare type Initialize = {
+    session_id?: string;
+    _skip_passphrase?: boolean;
+    derive_cardano?: boolean;
+};
+declare type GetFeatures = Empty;
+declare enum Enum_Capability {
+    Capability_Bitcoin = 1,
+    Capability_Bitcoin_like = 2,
+    Capability_Binance = 3,
+    Capability_Cardano = 4,
+    Capability_Crypto = 5,
+    Capability_EOS = 6,
+    Capability_Ethereum = 7,
+    Capability_Lisk = 8,
+    Capability_Monero = 9,
+    Capability_NEM = 10,
+    Capability_Ripple = 11,
+    Capability_Stellar = 12,
+    Capability_Tezos = 13,
+    Capability_U2F = 14,
+    Capability_Shamir = 15,
+    Capability_ShamirGroups = 16,
+    Capability_PassphraseEntry = 17
+}
+declare type Capability = keyof typeof Enum_Capability;
+declare type Features = {
+    vendor: string;
+    onekey_serial: string;
+    se_ver: string;
+    serial_no: string;
+    onekey_version: string;
+    ble_ver: string;
+    ble_enable: boolean;
+    major_version: number;
+    minor_version: number;
+    patch_version: number;
+    bootloader_mode: boolean | null;
+    device_id: string | null;
+    pin_protection: boolean | null;
+    passphrase_protection: boolean | null;
+    language: string | null;
+    label: string | null;
+    initialized: boolean | null;
+    revision: string | null;
+    bootloader_hash: string | null;
+    imported: boolean | null;
+    unlocked: boolean | null;
+    _passphrase_cached?: boolean;
+    firmware_present: boolean | null;
+    needs_backup: boolean | null;
+    flags: number | null;
+    model: string;
+    fw_major: number | null;
+    fw_minor: number | null;
+    fw_patch: number | null;
+    fw_vendor: string | null;
+    unfinished_backup: boolean | null;
+    no_backup: boolean | null;
+    recovery_mode: boolean | null;
+    capabilities: Capability[];
+    backup_type: BackupType | null;
+    sd_card_present: boolean | null;
+    sd_protection: boolean | null;
+    wipe_code_protection: boolean | null;
+    session_id: string | null;
+    passphrase_always_on_device: boolean | null;
+    safety_checks: SafetyCheckLevel | null;
+    auto_lock_delay_ms: number | null;
+    display_rotation: number | null;
+    experimental_features: boolean | null;
+};
+declare type LockDevice = Empty;
+declare type EndSession = Empty;
+declare type ApplySettings = {
+    language?: string;
+    label?: string;
+    use_passphrase?: boolean;
+    homescreen?: string;
+    _passphrase_source?: number;
+    auto_lock_delay_ms?: number;
+    display_rotation?: number;
+    passphrase_always_on_device?: boolean;
+    safety_checks?: SafetyCheckLevel;
+    experimental_features?: boolean;
+};
+declare type ApplyFlags = {
+    flags: number;
+};
+declare type ChangePin = {
+    remove?: boolean;
+};
+declare type ChangeWipeCode = {
+    remove?: boolean;
+};
+declare enum SdProtectOperationType {
+    DISABLE = 0,
+    ENABLE = 1,
+    REFRESH = 2
+}
+declare type SdProtect = {
+    operation: SdProtectOperationType;
+};
+declare type Ping = {
+    message?: string;
+    button_protection?: boolean;
+};
+declare type Cancel = Empty;
+declare type GetEntropy = {
+    size: number;
+};
+declare type Entropy = {
+    entropy: string;
+};
+declare type GetFirmwareHash = {
+    challenge?: string;
+};
+declare type FirmwareHash = {
+    hash: string;
+};
+declare type GetFirmware = Empty;
+declare type FirmwareChunk = {
+    chunk: string;
+};
+declare type FirmwareChunkAck = Empty;
+declare type WipeDevice = Empty;
+declare type ResetDevice = {
+    display_random?: boolean;
+    strength?: number;
+    passphrase_protection?: boolean;
+    pin_protection?: boolean;
+    language?: string;
+    label?: string;
+    u2f_counter?: number;
+    skip_backup?: boolean;
+    no_backup?: boolean;
+    backup_type?: string | number;
+};
+declare type BackupDevice = Empty;
+declare type EntropyRequest = Empty;
+declare type EntropyAck = {
+    entropy: string;
+};
+declare enum RecoveryDeviceType {
+    RecoveryDeviceType_ScrambledWords = 0,
+    RecoveryDeviceType_Matrix = 1
+}
+declare type RecoveryDevice = {
+    word_count?: number;
+    passphrase_protection?: boolean;
+    pin_protection?: boolean;
+    language?: string;
+    label?: string;
+    enforce_wordlist?: boolean;
+    type?: RecoveryDeviceType;
+    u2f_counter?: number;
+    dry_run?: boolean;
+};
+declare enum Enum_WordRequestType {
+    WordRequestType_Plain = 0,
+    WordRequestType_Matrix9 = 1,
+    WordRequestType_Matrix6 = 2
+}
+declare type WordRequestType = keyof typeof Enum_WordRequestType;
+declare type WordRequest = {
+    type: WordRequestType;
+};
+declare type WordAck = {
+    word: string;
+};
+declare type SetU2FCounter = {
+    u2f_counter: number;
+};
+declare type GetNextU2FCounter = Empty;
+declare type NextU2FCounter = {
+    u2f_counter: number;
+};
+declare type DoPreauthorized = Empty;
+declare type PreauthorizedRequest = Empty;
+declare type CancelAuthorization = Empty;
+declare type BixinReboot = Empty;
+declare type RebootToBootloader = Empty;
+declare type GetNonce = Empty;
+declare type Nonce = {
+    nonce: string;
+};
+declare type NEMGetAddress = {
+    address_n: number[];
+    network?: number;
+    show_display?: boolean;
+};
+declare type NEMAddress = {
+    address: string;
+};
+declare type NEMTransactionCommon = {
+    address_n?: number[];
+    network?: number;
+    timestamp: number;
+    fee: UintType;
+    deadline: number;
+    signer?: string;
+};
+declare type NEMMosaic = {
+    namespace: string;
+    mosaic: string;
+    quantity: number;
+};
+declare type NEMTransfer = {
+    recipient: string;
+    amount: UintType;
+    payload?: string;
+    public_key?: string;
+    mosaics?: NEMMosaic[];
+};
+declare type NEMProvisionNamespace = {
+    namespace: string;
+    parent?: string;
+    sink: string;
+    fee: UintType;
+};
+declare enum NEMMosaicLevy {
+    MosaicLevy_Absolute = 1,
+    MosaicLevy_Percentile = 2
+}
+declare type NEMMosaicDefinition = {
+    name?: string;
+    ticker?: string;
+    namespace: string;
+    mosaic: string;
+    divisibility?: number;
+    levy?: NEMMosaicLevy;
+    fee?: UintType;
+    levy_address?: string;
+    levy_namespace?: string;
+    levy_mosaic?: string;
+    supply?: number;
+    mutable_supply?: boolean;
+    transferable?: boolean;
+    description: string;
+    networks?: number[];
+};
+declare type NEMMosaicCreation = {
+    definition: NEMMosaicDefinition;
+    sink: string;
+    fee: UintType;
+};
+declare enum NEMSupplyChangeType {
+    SupplyChange_Increase = 1,
+    SupplyChange_Decrease = 2
+}
+declare type NEMMosaicSupplyChange = {
+    namespace: string;
+    mosaic: string;
+    type: NEMSupplyChangeType;
+    delta: number;
+};
+declare enum NEMModificationType {
+    CosignatoryModification_Add = 1,
+    CosignatoryModification_Delete = 2
+}
+declare type NEMCosignatoryModification = {
+    type: NEMModificationType;
+    public_key: string;
+};
+declare type NEMAggregateModification = {
+    modifications?: NEMCosignatoryModification[];
+    relative_change?: number;
+};
+declare enum NEMImportanceTransferMode {
+    ImportanceTransfer_Activate = 1,
+    ImportanceTransfer_Deactivate = 2
+}
+declare type NEMImportanceTransfer = {
+    mode: NEMImportanceTransferMode;
+    public_key: string;
+};
+declare type NEMSignTx = {
+    transaction: NEMTransactionCommon;
+    multisig?: NEMTransactionCommon;
+    transfer?: NEMTransfer;
+    cosigning?: boolean;
+    provision_namespace?: NEMProvisionNamespace;
+    mosaic_creation?: NEMMosaicCreation;
+    supply_change?: NEMMosaicSupplyChange;
+    aggregate_modification?: NEMAggregateModification;
+    importance_transfer?: NEMImportanceTransfer;
+};
+declare type NEMSignedTx = {
+    data: string;
+    signature: string;
+};
+declare type NEMDecryptMessage = {
+    address_n: number[];
+    network?: number;
+    public_key?: string;
+    payload?: string;
+};
+declare type NEMDecryptedMessage = {
+    payload: string;
+};
+declare type RippleGetAddress = {
+    address_n: number[];
+    show_display?: boolean;
+};
+declare type RippleAddress = {
+    address: string;
+};
+declare type RipplePayment = {
+    amount: UintType;
+    destination: string;
+    destination_tag?: number;
+};
+declare type RippleSignTx = {
+    address_n: number[];
+    fee: UintType;
+    flags?: number;
+    sequence: number;
+    last_ledger_sequence?: number;
+    payment: RipplePayment;
+};
+declare type RippleSignedTx = {
+    signature: string;
+    serialized_tx: string;
+};
+declare enum StellarAssetType {
+    NATIVE = 0,
+    ALPHANUM4 = 1,
+    ALPHANUM12 = 2
+}
+declare type StellarAsset = {
+    type: StellarAssetType;
+    code?: string;
+    issuer?: string;
+};
+declare type StellarGetAddress = {
+    address_n: number[];
+    show_display?: boolean;
+};
+declare type StellarAddress = {
+    address: string;
+};
+declare enum StellarMemoType {
+    NONE = 0,
+    TEXT = 1,
+    ID = 2,
+    HASH = 3,
+    RETURN = 4
+}
+declare type StellarSignTx = {
+    address_n: number[];
+    network_passphrase: string;
+    source_account: string;
+    fee: UintType;
+    sequence_number: UintType;
+    timebounds_start: number;
+    timebounds_end: number;
+    memo_type: StellarMemoType;
+    memo_text?: string;
+    memo_id?: string;
+    memo_hash?: Buffer | string;
+    num_operations: number;
+};
+declare type StellarTxOpRequest = Empty;
+declare type StellarPaymentOp = {
+    source_account?: string;
+    destination_account: string;
+    asset: StellarAsset;
+    amount: UintType;
+};
+declare type StellarCreateAccountOp = {
+    source_account?: string;
+    new_account: string;
+    starting_balance: UintType;
+};
+declare type StellarPathPaymentStrictReceiveOp = {
+    source_account?: string;
+    send_asset: StellarAsset;
+    send_max: UintType;
+    destination_account: string;
+    destination_asset: StellarAsset;
+    destination_amount: UintType;
+    paths?: StellarAsset[];
+};
+declare type StellarPathPaymentStrictSendOp = {
+    source_account?: string;
+    send_asset: StellarAsset;
+    send_amount: UintType;
+    destination_account: string;
+    destination_asset: StellarAsset;
+    destination_min: UintType;
+    paths?: StellarAsset[];
+};
+declare type StellarManageSellOfferOp = {
+    source_account?: string;
+    selling_asset: StellarAsset;
+    buying_asset: StellarAsset;
+    amount: UintType;
+    price_n: number;
+    price_d: number;
+    offer_id: UintType;
+};
+declare type StellarManageBuyOfferOp = {
+    source_account?: string;
+    selling_asset: StellarAsset;
+    buying_asset: StellarAsset;
+    amount: UintType;
+    price_n: number;
+    price_d: number;
+    offer_id: UintType;
+};
+declare type StellarCreatePassiveSellOfferOp = {
+    source_account?: string;
+    selling_asset: StellarAsset;
+    buying_asset: StellarAsset;
+    amount: UintType;
+    price_n: number;
+    price_d: number;
+};
+declare enum StellarSignerType {
+    ACCOUNT = 0,
+    PRE_AUTH = 1,
+    HASH = 2
+}
+declare type StellarSetOptionsOp = {
+    source_account?: string;
+    inflation_destination_account?: string;
+    clear_flags?: number;
+    set_flags?: number;
+    master_weight?: UintType;
+    low_threshold?: UintType;
+    medium_threshold?: UintType;
+    high_threshold?: UintType;
+    home_domain?: string;
+    signer_type?: StellarSignerType;
+    signer_key?: Buffer | string;
+    signer_weight?: number;
+};
+declare type StellarChangeTrustOp = {
+    source_account?: string;
+    asset: StellarAsset;
+    limit: UintType;
+};
+declare type StellarAllowTrustOp = {
+    source_account?: string;
+    trusted_account: string;
+    asset_type: StellarAssetType;
+    asset_code?: string;
+    is_authorized: boolean;
+};
+declare type StellarAccountMergeOp = {
+    source_account?: string;
+    destination_account: string;
+};
+declare type StellarManageDataOp = {
+    source_account?: string;
+    key: string;
+    value?: Buffer | string;
+};
+declare type StellarBumpSequenceOp = {
+    source_account?: string;
+    bump_to: UintType;
+};
+declare type StellarSignedTx = {
+    public_key: string;
+    signature: string;
+};
+declare type TezosGetAddress = {
+    address_n: number[];
+    show_display?: boolean;
+};
+declare type TezosAddress = {
+    address: string;
+};
+declare type TezosGetPublicKey = {
+    address_n: number[];
+    show_display?: boolean;
+};
+declare type TezosPublicKey = {
+    public_key: string;
+};
+declare enum TezosContractType {
+    Implicit = 0,
+    Originated = 1
+}
+declare type TezosContractID = {
+    tag: number;
+    hash: Uint8Array;
+};
+declare type TezosRevealOp = {
+    source: Uint8Array;
+    fee: UintType;
+    counter: number;
+    gas_limit: number;
+    storage_limit: number;
+    public_key: Uint8Array;
+};
+declare type TezosManagerTransfer = {
+    destination: TezosContractID;
+    amount: UintType;
+};
+declare type TezosParametersManager = {
+    set_delegate?: Uint8Array;
+    cancel_delegate?: boolean;
+    transfer?: TezosManagerTransfer;
+};
+declare type TezosTransactionOp = {
+    source: Uint8Array;
+    fee: UintType;
+    counter: number;
+    gas_limit: number;
+    storage_limit: number;
+    amount: UintType;
+    destination: TezosContractID;
+    parameters?: number[];
+    parameters_manager?: TezosParametersManager;
+};
+declare type TezosOriginationOp = {
+    source: Uint8Array;
+    fee: UintType;
+    counter: number;
+    gas_limit: number;
+    storage_limit: number;
+    manager_pubkey?: string;
+    balance: number;
+    spendable?: boolean;
+    delegatable?: boolean;
+    delegate?: Uint8Array;
+    script: string | number[];
+};
+declare type TezosDelegationOp = {
+    source: Uint8Array;
+    fee: UintType;
+    counter: number;
+    gas_limit: number;
+    storage_limit: number;
+    delegate: Uint8Array;
+};
+declare type TezosProposalOp = {
+    source: string;
+    period: number;
+    proposals: string[];
+};
+declare enum TezosBallotType {
+    Yay = 0,
+    Nay = 1,
+    Pass = 2
+}
+declare type TezosBallotOp = {
+    source: string;
+    period: number;
+    proposal: string;
+    ballot: TezosBallotType;
+};
+declare type TezosSignTx = {
+    address_n: number[];
+    branch: Uint8Array;
+    reveal?: TezosRevealOp;
+    transaction?: TezosTransactionOp;
+    origination?: TezosOriginationOp;
+    delegation?: TezosDelegationOp;
+    proposal?: TezosProposalOp;
+    ballot?: TezosBallotOp;
+};
+declare type TezosSignedTx = {
+    signature: string;
+    sig_op_contents: string;
+    operation_hash: string;
+};
+declare type MessageType = {
+    BinanceGetAddress: BinanceGetAddress;
+    BinanceAddress: BinanceAddress;
+    BinanceGetPublicKey: BinanceGetPublicKey;
+    BinancePublicKey: BinancePublicKey;
+    BinanceSignTx: BinanceSignTx;
+    BinanceTxRequest: BinanceTxRequest;
+    BinanceCoin: BinanceCoin;
+    BinanceInputOutput: BinanceInputOutput;
+    BinanceTransferMsg: BinanceTransferMsg;
+    BinanceOrderMsg: BinanceOrderMsg;
+    BinanceCancelMsg: BinanceCancelMsg;
+    BinanceSignedTx: BinanceSignedTx;
+    HDNodeType: HDNodeType;
+    HDNodePathType: HDNodePathType;
+    MultisigRedeemScriptType: MultisigRedeemScriptType;
+    GetPublicKey: GetPublicKey;
+    PublicKey: PublicKey;
+    GetAddress: GetAddress;
+    Address: Address;
+    GetOwnershipId: GetOwnershipId;
+    OwnershipId: OwnershipId;
+    SignMessage: SignMessage;
+    MessageSignature: MessageSignature;
+    VerifyMessage: VerifyMessage;
+    SignTx: SignTx;
+    TxRequestDetailsType: TxRequestDetailsType;
+    TxRequestSerializedType: TxRequestSerializedType;
+    TxRequest: TxRequest;
+    TxInputType: TxInputType;
+    TxOutputBinType: TxOutputBinType;
+    TxOutputType: TxOutputType;
+    PrevTx: PrevTx;
+    PrevInput: PrevInput;
+    PrevOutput: PrevOutput;
+    TextMemo: TextMemo;
+    RefundMemo: RefundMemo;
+    CoinPurchaseMemo: CoinPurchaseMemo;
+    PaymentRequestMemo: PaymentRequestMemo;
+    TxAckPaymentRequest: TxAckPaymentRequest;
+    TxAck: TxAck;
+    TxAckInputWrapper: TxAckInputWrapper;
+    TxAckInput: TxAckInput;
+    TxAckOutputWrapper: TxAckOutputWrapper;
+    TxAckOutput: TxAckOutput;
+    TxAckPrevMeta: TxAckPrevMeta;
+    TxAckPrevInputWrapper: TxAckPrevInputWrapper;
+    TxAckPrevInput: TxAckPrevInput;
+    TxAckPrevOutputWrapper: TxAckPrevOutputWrapper;
+    TxAckPrevOutput: TxAckPrevOutput;
+    TxAckPrevExtraDataWrapper: TxAckPrevExtraDataWrapper;
+    TxAckPrevExtraData: TxAckPrevExtraData;
+    GetOwnershipProof: GetOwnershipProof;
+    OwnershipProof: OwnershipProof;
+    AuthorizeCoinJoin: AuthorizeCoinJoin;
+    FirmwareErase: FirmwareErase;
+    FirmwareRequest: FirmwareRequest;
+    FirmwareUpload: FirmwareUpload;
+    SelfTest: SelfTest;
+    CardanoBlockchainPointerType: CardanoBlockchainPointerType;
+    CardanoNativeScript: CardanoNativeScript;
+    CardanoGetNativeScriptHash: CardanoGetNativeScriptHash;
+    CardanoNativeScriptHash: CardanoNativeScriptHash;
+    CardanoAddressParametersType: CardanoAddressParametersType;
+    CardanoGetAddress: CardanoGetAddress;
+    CardanoAddress: CardanoAddress;
+    CardanoGetPublicKey: CardanoGetPublicKey;
+    CardanoPublicKey: CardanoPublicKey;
+    CardanoSignTxInit: CardanoSignTxInit;
+    CardanoTxInput: CardanoTxInput;
+    CardanoTxOutput: CardanoTxOutput;
+    CardanoAssetGroup: CardanoAssetGroup;
+    CardanoToken: CardanoToken;
+    CardanoPoolOwner: CardanoPoolOwner;
+    CardanoPoolRelayParameters: CardanoPoolRelayParameters;
+    CardanoPoolMetadataType: CardanoPoolMetadataType;
+    CardanoPoolParametersType: CardanoPoolParametersType;
+    CardanoTxCertificate: CardanoTxCertificate;
+    CardanoTxWithdrawal: CardanoTxWithdrawal;
+    CardanoCatalystRegistrationParametersType: CardanoCatalystRegistrationParametersType;
+    CardanoTxAuxiliaryData: CardanoTxAuxiliaryData;
+    CardanoTxMint: CardanoTxMint;
+    CardanoTxCollateralInput: CardanoTxCollateralInput;
+    CardanoTxRequiredSigner: CardanoTxRequiredSigner;
+    CardanoTxItemAck: CardanoTxItemAck;
+    CardanoTxAuxiliaryDataSupplement: CardanoTxAuxiliaryDataSupplement;
+    CardanoTxWitnessRequest: CardanoTxWitnessRequest;
+    CardanoTxWitnessResponse: CardanoTxWitnessResponse;
+    CardanoTxHostAck: CardanoTxHostAck;
+    CardanoTxBodyHash: CardanoTxBodyHash;
+    CardanoSignTxFinished: CardanoSignTxFinished;
+    CardanoTxInputType: CardanoTxInputType;
+    CardanoTokenType: CardanoTokenType;
+    CardanoAssetGroupType: CardanoAssetGroupType;
+    CardanoTxOutputType: CardanoTxOutputType;
+    CardanoPoolOwnerType: CardanoPoolOwnerType;
+    CardanoPoolRelayParametersType: CardanoPoolRelayParametersType;
+    CardanoTxCertificateType: CardanoTxCertificateType;
+    CardanoTxWithdrawalType: CardanoTxWithdrawalType;
+    CardanoTxAuxiliaryDataType: CardanoTxAuxiliaryDataType;
+    CardanoSignTx: CardanoSignTx;
+    CardanoSignedTxChunk: CardanoSignedTxChunk;
+    CardanoSignedTxChunkAck: CardanoSignedTxChunkAck;
+    CardanoSignedTx: CardanoSignedTx;
+    Success: Success;
+    Failure: Failure;
+    ButtonRequest: ButtonRequest;
+    ButtonAck: ButtonAck;
+    PinMatrixRequest: PinMatrixRequest;
+    PinMatrixAck: PinMatrixAck;
+    PassphraseRequest: PassphraseRequest;
+    PassphraseAck: PassphraseAck;
+    Deprecated_PassphraseStateRequest: Deprecated_PassphraseStateRequest;
+    Deprecated_PassphraseStateAck: Deprecated_PassphraseStateAck;
+    CipherKeyValue: CipherKeyValue;
+    CipheredKeyValue: CipheredKeyValue;
+    IdentityType: IdentityType;
+    SignIdentity: SignIdentity;
+    SignedIdentity: SignedIdentity;
+    GetECDHSessionKey: GetECDHSessionKey;
+    ECDHSessionKey: ECDHSessionKey;
+    EosGetPublicKey: EosGetPublicKey;
+    EosPublicKey: EosPublicKey;
+    EosTxHeader: EosTxHeader;
+    EosSignTx: EosSignTx;
+    EosTxActionRequest: EosTxActionRequest;
+    EosAsset: EosAsset;
+    EosPermissionLevel: EosPermissionLevel;
+    EosAuthorizationKey: EosAuthorizationKey;
+    EosAuthorizationAccount: EosAuthorizationAccount;
+    EosAuthorizationWait: EosAuthorizationWait;
+    EosAuthorization: EosAuthorization;
+    EosActionCommon: EosActionCommon;
+    EosActionTransfer: EosActionTransfer;
+    EosActionDelegate: EosActionDelegate;
+    EosActionUndelegate: EosActionUndelegate;
+    EosActionRefund: EosActionRefund;
+    EosActionBuyRam: EosActionBuyRam;
+    EosActionBuyRamBytes: EosActionBuyRamBytes;
+    EosActionSellRam: EosActionSellRam;
+    EosActionVoteProducer: EosActionVoteProducer;
+    EosActionUpdateAuth: EosActionUpdateAuth;
+    EosActionDeleteAuth: EosActionDeleteAuth;
+    EosActionLinkAuth: EosActionLinkAuth;
+    EosActionUnlinkAuth: EosActionUnlinkAuth;
+    EosActionNewAccount: EosActionNewAccount;
+    EosActionUnknown: EosActionUnknown;
+    EosTxActionAck: EosTxActionAck;
+    EosSignedTx: EosSignedTx;
+    EthereumSignTypedData: EthereumSignTypedData;
+    EthereumTypedDataStructRequest: EthereumTypedDataStructRequest;
+    EthereumFieldType: EthereumFieldType;
+    EthereumStructMember: EthereumStructMember;
+    EthereumTypedDataStructAck: EthereumTypedDataStructAck;
+    EthereumTypedDataValueRequest: EthereumTypedDataValueRequest;
+    EthereumTypedDataValueAck: EthereumTypedDataValueAck;
+    EthereumGetPublicKey: EthereumGetPublicKey;
+    EthereumPublicKey: EthereumPublicKey;
+    EthereumGetAddress: EthereumGetAddress;
+    EthereumAddress: EthereumAddress;
+    EthereumSignTx: EthereumSignTx;
+    EthereumAccessList: EthereumAccessList;
+    EthereumSignTxEIP1559: EthereumSignTxEIP1559;
+    EthereumTxRequest: EthereumTxRequest;
+    EthereumTxAck: EthereumTxAck;
+    EthereumSignMessage: EthereumSignMessage;
+    EthereumSignMessageEIP712: EthereumSignMessageEIP712;
+    EthereumMessageSignature: EthereumMessageSignature;
+    EthereumVerifyMessage: EthereumVerifyMessage;
+    EthereumSignTypedHash: EthereumSignTypedHash;
+    EthereumTypedDataSignature: EthereumTypedDataSignature;
+    Initialize: Initialize;
+    GetFeatures: GetFeatures;
+    Features: Features;
+    LockDevice: LockDevice;
+    EndSession: EndSession;
+    ApplySettings: ApplySettings;
+    ApplyFlags: ApplyFlags;
+    ChangePin: ChangePin;
+    ChangeWipeCode: ChangeWipeCode;
+    SdProtect: SdProtect;
+    Ping: Ping;
+    Cancel: Cancel;
+    GetEntropy: GetEntropy;
+    Entropy: Entropy;
+    GetFirmwareHash: GetFirmwareHash;
+    FirmwareHash: FirmwareHash;
+    GetFirmware: GetFirmware;
+    FirmwareChunk: FirmwareChunk;
+    FirmwareChunkAck: FirmwareChunkAck;
+    WipeDevice: WipeDevice;
+    ResetDevice: ResetDevice;
+    BackupDevice: BackupDevice;
+    EntropyRequest: EntropyRequest;
+    EntropyAck: EntropyAck;
+    RecoveryDevice: RecoveryDevice;
+    WordRequest: WordRequest;
+    WordAck: WordAck;
+    SetU2FCounter: SetU2FCounter;
+    GetNextU2FCounter: GetNextU2FCounter;
+    NextU2FCounter: NextU2FCounter;
+    DoPreauthorized: DoPreauthorized;
+    PreauthorizedRequest: PreauthorizedRequest;
+    CancelAuthorization: CancelAuthorization;
+    BixinReboot: BixinReboot;
+    RebootToBootloader: RebootToBootloader;
+    GetNonce: GetNonce;
+    Nonce: Nonce;
+    NEMGetAddress: NEMGetAddress;
+    NEMAddress: NEMAddress;
+    NEMTransactionCommon: NEMTransactionCommon;
+    NEMMosaic: NEMMosaic;
+    NEMTransfer: NEMTransfer;
+    NEMProvisionNamespace: NEMProvisionNamespace;
+    NEMMosaicDefinition: NEMMosaicDefinition;
+    NEMMosaicCreation: NEMMosaicCreation;
+    NEMMosaicSupplyChange: NEMMosaicSupplyChange;
+    NEMCosignatoryModification: NEMCosignatoryModification;
+    NEMAggregateModification: NEMAggregateModification;
+    NEMImportanceTransfer: NEMImportanceTransfer;
+    NEMSignTx: NEMSignTx;
+    NEMSignedTx: NEMSignedTx;
+    NEMDecryptMessage: NEMDecryptMessage;
+    NEMDecryptedMessage: NEMDecryptedMessage;
+    RippleGetAddress: RippleGetAddress;
+    RippleAddress: RippleAddress;
+    RipplePayment: RipplePayment;
+    RippleSignTx: RippleSignTx;
+    RippleSignedTx: RippleSignedTx;
+    StellarAsset: StellarAsset;
+    StellarGetAddress: StellarGetAddress;
+    StellarAddress: StellarAddress;
+    StellarSignTx: StellarSignTx;
+    StellarTxOpRequest: StellarTxOpRequest;
+    StellarPaymentOp: StellarPaymentOp;
+    StellarCreateAccountOp: StellarCreateAccountOp;
+    StellarPathPaymentStrictReceiveOp: StellarPathPaymentStrictReceiveOp;
+    StellarPathPaymentStrictSendOp: StellarPathPaymentStrictSendOp;
+    StellarManageSellOfferOp: StellarManageSellOfferOp;
+    StellarManageBuyOfferOp: StellarManageBuyOfferOp;
+    StellarCreatePassiveSellOfferOp: StellarCreatePassiveSellOfferOp;
+    StellarSetOptionsOp: StellarSetOptionsOp;
+    StellarChangeTrustOp: StellarChangeTrustOp;
+    StellarAllowTrustOp: StellarAllowTrustOp;
+    StellarAccountMergeOp: StellarAccountMergeOp;
+    StellarManageDataOp: StellarManageDataOp;
+    StellarBumpSequenceOp: StellarBumpSequenceOp;
+    StellarSignedTx: StellarSignedTx;
+    TezosGetAddress: TezosGetAddress;
+    TezosAddress: TezosAddress;
+    TezosGetPublicKey: TezosGetPublicKey;
+    TezosPublicKey: TezosPublicKey;
+    TezosContractID: TezosContractID;
+    TezosRevealOp: TezosRevealOp;
+    TezosManagerTransfer: TezosManagerTransfer;
+    TezosParametersManager: TezosParametersManager;
+    TezosTransactionOp: TezosTransactionOp;
+    TezosOriginationOp: TezosOriginationOp;
+    TezosDelegationOp: TezosDelegationOp;
+    TezosProposalOp: TezosProposalOp;
+    TezosBallotOp: TezosBallotOp;
+    TezosSignTx: TezosSignTx;
+    TezosSignedTx: TezosSignedTx;
+};
+declare type MessageKey = keyof MessageType;
+declare type MessageResponse<T extends MessageKey> = {
+    type: T;
+    message: MessageType[T];
+};
+declare type TypedCall = <T extends MessageKey, R extends MessageKey>(type: T, resType: R, message?: MessageType[T]) => Promise<MessageResponse<R>>;
+
+type messages_UintType = UintType;
+type messages_BinanceGetAddress = BinanceGetAddress;
+type messages_BinanceAddress = BinanceAddress;
+type messages_BinanceGetPublicKey = BinanceGetPublicKey;
+type messages_BinancePublicKey = BinancePublicKey;
+type messages_BinanceSignTx = BinanceSignTx;
+type messages_BinanceTxRequest = BinanceTxRequest;
+type messages_BinanceCoin = BinanceCoin;
+type messages_BinanceInputOutput = BinanceInputOutput;
+type messages_BinanceTransferMsg = BinanceTransferMsg;
+type messages_BinanceOrderType = BinanceOrderType;
+declare const messages_BinanceOrderType: typeof BinanceOrderType;
+type messages_BinanceOrderSide = BinanceOrderSide;
+declare const messages_BinanceOrderSide: typeof BinanceOrderSide;
+type messages_BinanceTimeInForce = BinanceTimeInForce;
+declare const messages_BinanceTimeInForce: typeof BinanceTimeInForce;
+type messages_BinanceOrderMsg = BinanceOrderMsg;
+type messages_BinanceCancelMsg = BinanceCancelMsg;
+type messages_BinanceSignedTx = BinanceSignedTx;
+type messages_Enum_InputScriptType = Enum_InputScriptType;
+declare const messages_Enum_InputScriptType: typeof Enum_InputScriptType;
+type messages_InputScriptType = InputScriptType;
+type messages_Enum_OutputScriptType = Enum_OutputScriptType;
+declare const messages_Enum_OutputScriptType: typeof Enum_OutputScriptType;
+type messages_OutputScriptType = OutputScriptType;
+type messages_DecredStakingSpendType = DecredStakingSpendType;
+declare const messages_DecredStakingSpendType: typeof DecredStakingSpendType;
+type messages_AmountUnit = AmountUnit;
+declare const messages_AmountUnit: typeof AmountUnit;
+type messages_HDNodeType = HDNodeType;
+type messages_HDNodePathType = HDNodePathType;
+type messages_MultisigRedeemScriptType = MultisigRedeemScriptType;
+type messages_GetPublicKey = GetPublicKey;
+type messages_PublicKey = PublicKey;
+type messages_GetAddress = GetAddress;
+type messages_Address = Address;
+type messages_GetOwnershipId = GetOwnershipId;
+type messages_OwnershipId = OwnershipId;
+type messages_SignMessage = SignMessage;
+type messages_MessageSignature = MessageSignature;
+type messages_VerifyMessage = VerifyMessage;
+type messages_SignTx = SignTx;
+type messages_Enum_RequestType = Enum_RequestType;
+declare const messages_Enum_RequestType: typeof Enum_RequestType;
+type messages_RequestType = RequestType;
+type messages_TxRequestDetailsType = TxRequestDetailsType;
+type messages_TxRequestSerializedType = TxRequestSerializedType;
+type messages_TxRequest = TxRequest;
+type messages_InternalInputScriptType = InternalInputScriptType;
+type messages_TxInputType = TxInputType;
+type messages_TxInput = TxInput;
+type messages_TxOutputBinType = TxOutputBinType;
+type messages_ChangeOutputScriptType = ChangeOutputScriptType;
+type messages_TxOutputType = TxOutputType;
+type messages_TxOutput = TxOutput;
+type messages_PrevTx = PrevTx;
+type messages_PrevInput = PrevInput;
+type messages_PrevOutput = PrevOutput;
+type messages_TextMemo = TextMemo;
+type messages_RefundMemo = RefundMemo;
+type messages_CoinPurchaseMemo = CoinPurchaseMemo;
+type messages_PaymentRequestMemo = PaymentRequestMemo;
+type messages_TxAckPaymentRequest = TxAckPaymentRequest;
+type messages_TxAckResponse = TxAckResponse;
+type messages_TxAck = TxAck;
+type messages_TxAckInputWrapper = TxAckInputWrapper;
+type messages_TxAckInput = TxAckInput;
+type messages_TxAckOutputWrapper = TxAckOutputWrapper;
+type messages_TxAckOutput = TxAckOutput;
+type messages_TxAckPrevMeta = TxAckPrevMeta;
+type messages_TxAckPrevInputWrapper = TxAckPrevInputWrapper;
+type messages_TxAckPrevInput = TxAckPrevInput;
+type messages_TxAckPrevOutputWrapper = TxAckPrevOutputWrapper;
+type messages_TxAckPrevOutput = TxAckPrevOutput;
+type messages_TxAckPrevExtraDataWrapper = TxAckPrevExtraDataWrapper;
+type messages_TxAckPrevExtraData = TxAckPrevExtraData;
+type messages_GetOwnershipProof = GetOwnershipProof;
+type messages_OwnershipProof = OwnershipProof;
+type messages_AuthorizeCoinJoin = AuthorizeCoinJoin;
+type messages_FirmwareErase = FirmwareErase;
+type messages_FirmwareRequest = FirmwareRequest;
+type messages_FirmwareUpload = FirmwareUpload;
+type messages_SelfTest = SelfTest;
+type messages_CardanoDerivationType = CardanoDerivationType;
+declare const messages_CardanoDerivationType: typeof CardanoDerivationType;
+type messages_CardanoAddressType = CardanoAddressType;
+declare const messages_CardanoAddressType: typeof CardanoAddressType;
+type messages_CardanoNativeScriptType = CardanoNativeScriptType;
+declare const messages_CardanoNativeScriptType: typeof CardanoNativeScriptType;
+type messages_CardanoNativeScriptHashDisplayFormat = CardanoNativeScriptHashDisplayFormat;
+declare const messages_CardanoNativeScriptHashDisplayFormat: typeof CardanoNativeScriptHashDisplayFormat;
+type messages_CardanoCertificateType = CardanoCertificateType;
+declare const messages_CardanoCertificateType: typeof CardanoCertificateType;
+type messages_CardanoPoolRelayType = CardanoPoolRelayType;
+declare const messages_CardanoPoolRelayType: typeof CardanoPoolRelayType;
+type messages_CardanoTxAuxiliaryDataSupplementType = CardanoTxAuxiliaryDataSupplementType;
+declare const messages_CardanoTxAuxiliaryDataSupplementType: typeof CardanoTxAuxiliaryDataSupplementType;
+type messages_CardanoTxSigningMode = CardanoTxSigningMode;
+declare const messages_CardanoTxSigningMode: typeof CardanoTxSigningMode;
+type messages_CardanoTxWitnessType = CardanoTxWitnessType;
+declare const messages_CardanoTxWitnessType: typeof CardanoTxWitnessType;
+type messages_CardanoBlockchainPointerType = CardanoBlockchainPointerType;
+type messages_CardanoNativeScript = CardanoNativeScript;
+type messages_CardanoGetNativeScriptHash = CardanoGetNativeScriptHash;
+type messages_CardanoNativeScriptHash = CardanoNativeScriptHash;
+type messages_CardanoAddressParametersType = CardanoAddressParametersType;
+type messages_CardanoGetAddress = CardanoGetAddress;
+type messages_CardanoAddress = CardanoAddress;
+type messages_CardanoGetPublicKey = CardanoGetPublicKey;
+type messages_CardanoPublicKey = CardanoPublicKey;
+type messages_CardanoSignTxInit = CardanoSignTxInit;
+type messages_CardanoTxInput = CardanoTxInput;
+type messages_CardanoTxOutput = CardanoTxOutput;
+type messages_CardanoAssetGroup = CardanoAssetGroup;
+type messages_CardanoToken = CardanoToken;
+type messages_CardanoPoolOwner = CardanoPoolOwner;
+type messages_CardanoPoolRelayParameters = CardanoPoolRelayParameters;
+type messages_CardanoPoolMetadataType = CardanoPoolMetadataType;
+type messages_CardanoPoolParametersType = CardanoPoolParametersType;
+type messages_CardanoTxCertificate = CardanoTxCertificate;
+type messages_CardanoTxWithdrawal = CardanoTxWithdrawal;
+type messages_CardanoCatalystRegistrationParametersType = CardanoCatalystRegistrationParametersType;
+type messages_CardanoTxAuxiliaryData = CardanoTxAuxiliaryData;
+type messages_CardanoTxMint = CardanoTxMint;
+type messages_CardanoTxCollateralInput = CardanoTxCollateralInput;
+type messages_CardanoTxRequiredSigner = CardanoTxRequiredSigner;
+type messages_CardanoTxItemAck = CardanoTxItemAck;
+type messages_CardanoTxAuxiliaryDataSupplement = CardanoTxAuxiliaryDataSupplement;
+type messages_CardanoTxWitnessRequest = CardanoTxWitnessRequest;
+type messages_CardanoTxWitnessResponse = CardanoTxWitnessResponse;
+type messages_CardanoTxHostAck = CardanoTxHostAck;
+type messages_CardanoTxBodyHash = CardanoTxBodyHash;
+type messages_CardanoSignTxFinished = CardanoSignTxFinished;
+type messages_CardanoTxInputType = CardanoTxInputType;
+type messages_CardanoTokenType = CardanoTokenType;
+type messages_CardanoAssetGroupType = CardanoAssetGroupType;
+type messages_CardanoTxOutputType = CardanoTxOutputType;
+type messages_CardanoPoolOwnerType = CardanoPoolOwnerType;
+type messages_CardanoPoolRelayParametersType = CardanoPoolRelayParametersType;
+type messages_CardanoTxCertificateType = CardanoTxCertificateType;
+type messages_CardanoTxWithdrawalType = CardanoTxWithdrawalType;
+type messages_CardanoTxAuxiliaryDataType = CardanoTxAuxiliaryDataType;
+type messages_CardanoSignTx = CardanoSignTx;
+type messages_CardanoSignedTxChunk = CardanoSignedTxChunk;
+type messages_CardanoSignedTxChunkAck = CardanoSignedTxChunkAck;
+type messages_CardanoSignedTx = CardanoSignedTx;
+type messages_Success = Success;
+type messages_FailureType = FailureType;
+declare const messages_FailureType: typeof FailureType;
+type messages_Failure = Failure;
+type messages_Enum_ButtonRequestType = Enum_ButtonRequestType;
+declare const messages_Enum_ButtonRequestType: typeof Enum_ButtonRequestType;
+type messages_ButtonRequestType = ButtonRequestType;
+type messages_ButtonRequest = ButtonRequest;
+type messages_ButtonAck = ButtonAck;
+type messages_Enum_PinMatrixRequestType = Enum_PinMatrixRequestType;
+declare const messages_Enum_PinMatrixRequestType: typeof Enum_PinMatrixRequestType;
+type messages_PinMatrixRequestType = PinMatrixRequestType;
+type messages_PinMatrixRequest = PinMatrixRequest;
+type messages_PinMatrixAck = PinMatrixAck;
+type messages_PassphraseRequest = PassphraseRequest;
+type messages_PassphraseAck = PassphraseAck;
+type messages_Deprecated_PassphraseStateRequest = Deprecated_PassphraseStateRequest;
+type messages_Deprecated_PassphraseStateAck = Deprecated_PassphraseStateAck;
+type messages_CipherKeyValue = CipherKeyValue;
+type messages_CipheredKeyValue = CipheredKeyValue;
+type messages_IdentityType = IdentityType;
+type messages_SignIdentity = SignIdentity;
+type messages_SignedIdentity = SignedIdentity;
+type messages_GetECDHSessionKey = GetECDHSessionKey;
+type messages_ECDHSessionKey = ECDHSessionKey;
+type messages_DebugButton = DebugButton;
+declare const messages_DebugButton: typeof DebugButton;
+type messages_EosGetPublicKey = EosGetPublicKey;
+type messages_EosPublicKey = EosPublicKey;
+type messages_EosTxHeader = EosTxHeader;
+type messages_EosSignTx = EosSignTx;
+type messages_EosTxActionRequest = EosTxActionRequest;
+type messages_EosAsset = EosAsset;
+type messages_EosPermissionLevel = EosPermissionLevel;
+type messages_EosAuthorizationKey = EosAuthorizationKey;
+type messages_EosAuthorizationAccount = EosAuthorizationAccount;
+type messages_EosAuthorizationWait = EosAuthorizationWait;
+type messages_EosAuthorization = EosAuthorization;
+type messages_EosActionCommon = EosActionCommon;
+type messages_EosActionTransfer = EosActionTransfer;
+type messages_EosActionDelegate = EosActionDelegate;
+type messages_EosActionUndelegate = EosActionUndelegate;
+type messages_EosActionRefund = EosActionRefund;
+type messages_EosActionBuyRam = EosActionBuyRam;
+type messages_EosActionBuyRamBytes = EosActionBuyRamBytes;
+type messages_EosActionSellRam = EosActionSellRam;
+type messages_EosActionVoteProducer = EosActionVoteProducer;
+type messages_EosActionUpdateAuth = EosActionUpdateAuth;
+type messages_EosActionDeleteAuth = EosActionDeleteAuth;
+type messages_EosActionLinkAuth = EosActionLinkAuth;
+type messages_EosActionUnlinkAuth = EosActionUnlinkAuth;
+type messages_EosActionNewAccount = EosActionNewAccount;
+type messages_EosActionUnknown = EosActionUnknown;
+type messages_EosTxActionAck = EosTxActionAck;
+type messages_EosSignedTx = EosSignedTx;
+type messages_EthereumSignTypedData = EthereumSignTypedData;
+type messages_EthereumTypedDataStructRequest = EthereumTypedDataStructRequest;
+type messages_EthereumDataType = EthereumDataType;
+declare const messages_EthereumDataType: typeof EthereumDataType;
+type messages_EthereumFieldType = EthereumFieldType;
+type messages_EthereumStructMember = EthereumStructMember;
+type messages_EthereumTypedDataStructAck = EthereumTypedDataStructAck;
+type messages_EthereumTypedDataValueRequest = EthereumTypedDataValueRequest;
+type messages_EthereumTypedDataValueAck = EthereumTypedDataValueAck;
+type messages_EthereumGetPublicKey = EthereumGetPublicKey;
+type messages_EthereumPublicKey = EthereumPublicKey;
+type messages_EthereumGetAddress = EthereumGetAddress;
+type messages_EthereumAddress = EthereumAddress;
+type messages_EthereumSignTx = EthereumSignTx;
+type messages_EthereumAccessList = EthereumAccessList;
+type messages_EthereumSignTxEIP1559 = EthereumSignTxEIP1559;
+type messages_EthereumTxRequest = EthereumTxRequest;
+type messages_EthereumTxAck = EthereumTxAck;
+type messages_EthereumSignMessage = EthereumSignMessage;
+type messages_EthereumSignMessageEIP712 = EthereumSignMessageEIP712;
+type messages_EthereumMessageSignature = EthereumMessageSignature;
+type messages_EthereumVerifyMessage = EthereumVerifyMessage;
+type messages_EthereumSignTypedHash = EthereumSignTypedHash;
+type messages_EthereumTypedDataSignature = EthereumTypedDataSignature;
+type messages_Enum_BackupType = Enum_BackupType;
+declare const messages_Enum_BackupType: typeof Enum_BackupType;
+type messages_BackupType = BackupType;
+type messages_Enum_SafetyCheckLevel = Enum_SafetyCheckLevel;
+declare const messages_Enum_SafetyCheckLevel: typeof Enum_SafetyCheckLevel;
+type messages_SafetyCheckLevel = SafetyCheckLevel;
+type messages_Initialize = Initialize;
+type messages_GetFeatures = GetFeatures;
+type messages_Enum_Capability = Enum_Capability;
+declare const messages_Enum_Capability: typeof Enum_Capability;
+type messages_Capability = Capability;
+type messages_Features = Features;
+type messages_LockDevice = LockDevice;
+type messages_EndSession = EndSession;
+type messages_ApplySettings = ApplySettings;
+type messages_ApplyFlags = ApplyFlags;
+type messages_ChangePin = ChangePin;
+type messages_ChangeWipeCode = ChangeWipeCode;
+type messages_SdProtectOperationType = SdProtectOperationType;
+declare const messages_SdProtectOperationType: typeof SdProtectOperationType;
+type messages_SdProtect = SdProtect;
+type messages_Ping = Ping;
+type messages_Cancel = Cancel;
+type messages_GetEntropy = GetEntropy;
+type messages_Entropy = Entropy;
+type messages_GetFirmwareHash = GetFirmwareHash;
+type messages_FirmwareHash = FirmwareHash;
+type messages_GetFirmware = GetFirmware;
+type messages_FirmwareChunk = FirmwareChunk;
+type messages_FirmwareChunkAck = FirmwareChunkAck;
+type messages_WipeDevice = WipeDevice;
+type messages_ResetDevice = ResetDevice;
+type messages_BackupDevice = BackupDevice;
+type messages_EntropyRequest = EntropyRequest;
+type messages_EntropyAck = EntropyAck;
+type messages_RecoveryDeviceType = RecoveryDeviceType;
+declare const messages_RecoveryDeviceType: typeof RecoveryDeviceType;
+type messages_RecoveryDevice = RecoveryDevice;
+type messages_Enum_WordRequestType = Enum_WordRequestType;
+declare const messages_Enum_WordRequestType: typeof Enum_WordRequestType;
+type messages_WordRequestType = WordRequestType;
+type messages_WordRequest = WordRequest;
+type messages_WordAck = WordAck;
+type messages_SetU2FCounter = SetU2FCounter;
+type messages_GetNextU2FCounter = GetNextU2FCounter;
+type messages_NextU2FCounter = NextU2FCounter;
+type messages_DoPreauthorized = DoPreauthorized;
+type messages_PreauthorizedRequest = PreauthorizedRequest;
+type messages_CancelAuthorization = CancelAuthorization;
+type messages_BixinReboot = BixinReboot;
+type messages_RebootToBootloader = RebootToBootloader;
+type messages_GetNonce = GetNonce;
+type messages_Nonce = Nonce;
+type messages_NEMGetAddress = NEMGetAddress;
+type messages_NEMAddress = NEMAddress;
+type messages_NEMTransactionCommon = NEMTransactionCommon;
+type messages_NEMMosaic = NEMMosaic;
+type messages_NEMTransfer = NEMTransfer;
+type messages_NEMProvisionNamespace = NEMProvisionNamespace;
+type messages_NEMMosaicLevy = NEMMosaicLevy;
+declare const messages_NEMMosaicLevy: typeof NEMMosaicLevy;
+type messages_NEMMosaicDefinition = NEMMosaicDefinition;
+type messages_NEMMosaicCreation = NEMMosaicCreation;
+type messages_NEMSupplyChangeType = NEMSupplyChangeType;
+declare const messages_NEMSupplyChangeType: typeof NEMSupplyChangeType;
+type messages_NEMMosaicSupplyChange = NEMMosaicSupplyChange;
+type messages_NEMModificationType = NEMModificationType;
+declare const messages_NEMModificationType: typeof NEMModificationType;
+type messages_NEMCosignatoryModification = NEMCosignatoryModification;
+type messages_NEMAggregateModification = NEMAggregateModification;
+type messages_NEMImportanceTransferMode = NEMImportanceTransferMode;
+declare const messages_NEMImportanceTransferMode: typeof NEMImportanceTransferMode;
+type messages_NEMImportanceTransfer = NEMImportanceTransfer;
+type messages_NEMSignTx = NEMSignTx;
+type messages_NEMSignedTx = NEMSignedTx;
+type messages_NEMDecryptMessage = NEMDecryptMessage;
+type messages_NEMDecryptedMessage = NEMDecryptedMessage;
+type messages_RippleGetAddress = RippleGetAddress;
+type messages_RippleAddress = RippleAddress;
+type messages_RipplePayment = RipplePayment;
+type messages_RippleSignTx = RippleSignTx;
+type messages_RippleSignedTx = RippleSignedTx;
+type messages_StellarAssetType = StellarAssetType;
+declare const messages_StellarAssetType: typeof StellarAssetType;
+type messages_StellarAsset = StellarAsset;
+type messages_StellarGetAddress = StellarGetAddress;
+type messages_StellarAddress = StellarAddress;
+type messages_StellarMemoType = StellarMemoType;
+declare const messages_StellarMemoType: typeof StellarMemoType;
+type messages_StellarSignTx = StellarSignTx;
+type messages_StellarTxOpRequest = StellarTxOpRequest;
+type messages_StellarPaymentOp = StellarPaymentOp;
+type messages_StellarCreateAccountOp = StellarCreateAccountOp;
+type messages_StellarPathPaymentStrictReceiveOp = StellarPathPaymentStrictReceiveOp;
+type messages_StellarPathPaymentStrictSendOp = StellarPathPaymentStrictSendOp;
+type messages_StellarManageSellOfferOp = StellarManageSellOfferOp;
+type messages_StellarManageBuyOfferOp = StellarManageBuyOfferOp;
+type messages_StellarCreatePassiveSellOfferOp = StellarCreatePassiveSellOfferOp;
+type messages_StellarSignerType = StellarSignerType;
+declare const messages_StellarSignerType: typeof StellarSignerType;
+type messages_StellarSetOptionsOp = StellarSetOptionsOp;
+type messages_StellarChangeTrustOp = StellarChangeTrustOp;
+type messages_StellarAllowTrustOp = StellarAllowTrustOp;
+type messages_StellarAccountMergeOp = StellarAccountMergeOp;
+type messages_StellarManageDataOp = StellarManageDataOp;
+type messages_StellarBumpSequenceOp = StellarBumpSequenceOp;
+type messages_StellarSignedTx = StellarSignedTx;
+type messages_TezosGetAddress = TezosGetAddress;
+type messages_TezosAddress = TezosAddress;
+type messages_TezosGetPublicKey = TezosGetPublicKey;
+type messages_TezosPublicKey = TezosPublicKey;
+type messages_TezosContractType = TezosContractType;
+declare const messages_TezosContractType: typeof TezosContractType;
+type messages_TezosContractID = TezosContractID;
+type messages_TezosRevealOp = TezosRevealOp;
+type messages_TezosManagerTransfer = TezosManagerTransfer;
+type messages_TezosParametersManager = TezosParametersManager;
+type messages_TezosTransactionOp = TezosTransactionOp;
+type messages_TezosOriginationOp = TezosOriginationOp;
+type messages_TezosDelegationOp = TezosDelegationOp;
+type messages_TezosProposalOp = TezosProposalOp;
+type messages_TezosBallotType = TezosBallotType;
+declare const messages_TezosBallotType: typeof TezosBallotType;
+type messages_TezosBallotOp = TezosBallotOp;
+type messages_TezosSignTx = TezosSignTx;
+type messages_TezosSignedTx = TezosSignedTx;
+type messages_MessageType = MessageType;
+type messages_MessageKey = MessageKey;
+type messages_MessageResponse<T extends MessageKey> = MessageResponse<T>;
+type messages_TypedCall = TypedCall;
+declare namespace messages {
+  export {
+    messages_UintType as UintType,
+    messages_BinanceGetAddress as BinanceGetAddress,
+    messages_BinanceAddress as BinanceAddress,
+    messages_BinanceGetPublicKey as BinanceGetPublicKey,
+    messages_BinancePublicKey as BinancePublicKey,
+    messages_BinanceSignTx as BinanceSignTx,
+    messages_BinanceTxRequest as BinanceTxRequest,
+    messages_BinanceCoin as BinanceCoin,
+    messages_BinanceInputOutput as BinanceInputOutput,
+    messages_BinanceTransferMsg as BinanceTransferMsg,
+    messages_BinanceOrderType as BinanceOrderType,
+    messages_BinanceOrderSide as BinanceOrderSide,
+    messages_BinanceTimeInForce as BinanceTimeInForce,
+    messages_BinanceOrderMsg as BinanceOrderMsg,
+    messages_BinanceCancelMsg as BinanceCancelMsg,
+    messages_BinanceSignedTx as BinanceSignedTx,
+    messages_Enum_InputScriptType as Enum_InputScriptType,
+    messages_InputScriptType as InputScriptType,
+    messages_Enum_OutputScriptType as Enum_OutputScriptType,
+    messages_OutputScriptType as OutputScriptType,
+    messages_DecredStakingSpendType as DecredStakingSpendType,
+    messages_AmountUnit as AmountUnit,
+    messages_HDNodeType as HDNodeType,
+    messages_HDNodePathType as HDNodePathType,
+    messages_MultisigRedeemScriptType as MultisigRedeemScriptType,
+    messages_GetPublicKey as GetPublicKey,
+    messages_PublicKey as PublicKey,
+    messages_GetAddress as GetAddress,
+    messages_Address as Address,
+    messages_GetOwnershipId as GetOwnershipId,
+    messages_OwnershipId as OwnershipId,
+    messages_SignMessage as SignMessage,
+    messages_MessageSignature as MessageSignature,
+    messages_VerifyMessage as VerifyMessage,
+    messages_SignTx as SignTx,
+    messages_Enum_RequestType as Enum_RequestType,
+    messages_RequestType as RequestType,
+    messages_TxRequestDetailsType as TxRequestDetailsType,
+    messages_TxRequestSerializedType as TxRequestSerializedType,
+    messages_TxRequest as TxRequest,
+    messages_InternalInputScriptType as InternalInputScriptType,
+    messages_TxInputType as TxInputType,
+    messages_TxInput as TxInput,
+    messages_TxOutputBinType as TxOutputBinType,
+    messages_ChangeOutputScriptType as ChangeOutputScriptType,
+    messages_TxOutputType as TxOutputType,
+    messages_TxOutput as TxOutput,
+    messages_PrevTx as PrevTx,
+    messages_PrevInput as PrevInput,
+    messages_PrevOutput as PrevOutput,
+    messages_TextMemo as TextMemo,
+    messages_RefundMemo as RefundMemo,
+    messages_CoinPurchaseMemo as CoinPurchaseMemo,
+    messages_PaymentRequestMemo as PaymentRequestMemo,
+    messages_TxAckPaymentRequest as TxAckPaymentRequest,
+    messages_TxAckResponse as TxAckResponse,
+    messages_TxAck as TxAck,
+    messages_TxAckInputWrapper as TxAckInputWrapper,
+    messages_TxAckInput as TxAckInput,
+    messages_TxAckOutputWrapper as TxAckOutputWrapper,
+    messages_TxAckOutput as TxAckOutput,
+    messages_TxAckPrevMeta as TxAckPrevMeta,
+    messages_TxAckPrevInputWrapper as TxAckPrevInputWrapper,
+    messages_TxAckPrevInput as TxAckPrevInput,
+    messages_TxAckPrevOutputWrapper as TxAckPrevOutputWrapper,
+    messages_TxAckPrevOutput as TxAckPrevOutput,
+    messages_TxAckPrevExtraDataWrapper as TxAckPrevExtraDataWrapper,
+    messages_TxAckPrevExtraData as TxAckPrevExtraData,
+    messages_GetOwnershipProof as GetOwnershipProof,
+    messages_OwnershipProof as OwnershipProof,
+    messages_AuthorizeCoinJoin as AuthorizeCoinJoin,
+    messages_FirmwareErase as FirmwareErase,
+    messages_FirmwareRequest as FirmwareRequest,
+    messages_FirmwareUpload as FirmwareUpload,
+    messages_SelfTest as SelfTest,
+    messages_CardanoDerivationType as CardanoDerivationType,
+    messages_CardanoAddressType as CardanoAddressType,
+    messages_CardanoNativeScriptType as CardanoNativeScriptType,
+    messages_CardanoNativeScriptHashDisplayFormat as CardanoNativeScriptHashDisplayFormat,
+    messages_CardanoCertificateType as CardanoCertificateType,
+    messages_CardanoPoolRelayType as CardanoPoolRelayType,
+    messages_CardanoTxAuxiliaryDataSupplementType as CardanoTxAuxiliaryDataSupplementType,
+    messages_CardanoTxSigningMode as CardanoTxSigningMode,
+    messages_CardanoTxWitnessType as CardanoTxWitnessType,
+    messages_CardanoBlockchainPointerType as CardanoBlockchainPointerType,
+    messages_CardanoNativeScript as CardanoNativeScript,
+    messages_CardanoGetNativeScriptHash as CardanoGetNativeScriptHash,
+    messages_CardanoNativeScriptHash as CardanoNativeScriptHash,
+    messages_CardanoAddressParametersType as CardanoAddressParametersType,
+    messages_CardanoGetAddress as CardanoGetAddress,
+    messages_CardanoAddress as CardanoAddress,
+    messages_CardanoGetPublicKey as CardanoGetPublicKey,
+    messages_CardanoPublicKey as CardanoPublicKey,
+    messages_CardanoSignTxInit as CardanoSignTxInit,
+    messages_CardanoTxInput as CardanoTxInput,
+    messages_CardanoTxOutput as CardanoTxOutput,
+    messages_CardanoAssetGroup as CardanoAssetGroup,
+    messages_CardanoToken as CardanoToken,
+    messages_CardanoPoolOwner as CardanoPoolOwner,
+    messages_CardanoPoolRelayParameters as CardanoPoolRelayParameters,
+    messages_CardanoPoolMetadataType as CardanoPoolMetadataType,
+    messages_CardanoPoolParametersType as CardanoPoolParametersType,
+    messages_CardanoTxCertificate as CardanoTxCertificate,
+    messages_CardanoTxWithdrawal as CardanoTxWithdrawal,
+    messages_CardanoCatalystRegistrationParametersType as CardanoCatalystRegistrationParametersType,
+    messages_CardanoTxAuxiliaryData as CardanoTxAuxiliaryData,
+    messages_CardanoTxMint as CardanoTxMint,
+    messages_CardanoTxCollateralInput as CardanoTxCollateralInput,
+    messages_CardanoTxRequiredSigner as CardanoTxRequiredSigner,
+    messages_CardanoTxItemAck as CardanoTxItemAck,
+    messages_CardanoTxAuxiliaryDataSupplement as CardanoTxAuxiliaryDataSupplement,
+    messages_CardanoTxWitnessRequest as CardanoTxWitnessRequest,
+    messages_CardanoTxWitnessResponse as CardanoTxWitnessResponse,
+    messages_CardanoTxHostAck as CardanoTxHostAck,
+    messages_CardanoTxBodyHash as CardanoTxBodyHash,
+    messages_CardanoSignTxFinished as CardanoSignTxFinished,
+    messages_CardanoTxInputType as CardanoTxInputType,
+    messages_CardanoTokenType as CardanoTokenType,
+    messages_CardanoAssetGroupType as CardanoAssetGroupType,
+    messages_CardanoTxOutputType as CardanoTxOutputType,
+    messages_CardanoPoolOwnerType as CardanoPoolOwnerType,
+    messages_CardanoPoolRelayParametersType as CardanoPoolRelayParametersType,
+    messages_CardanoTxCertificateType as CardanoTxCertificateType,
+    messages_CardanoTxWithdrawalType as CardanoTxWithdrawalType,
+    messages_CardanoTxAuxiliaryDataType as CardanoTxAuxiliaryDataType,
+    messages_CardanoSignTx as CardanoSignTx,
+    messages_CardanoSignedTxChunk as CardanoSignedTxChunk,
+    messages_CardanoSignedTxChunkAck as CardanoSignedTxChunkAck,
+    messages_CardanoSignedTx as CardanoSignedTx,
+    messages_Success as Success,
+    messages_FailureType as FailureType,
+    messages_Failure as Failure,
+    messages_Enum_ButtonRequestType as Enum_ButtonRequestType,
+    messages_ButtonRequestType as ButtonRequestType,
+    messages_ButtonRequest as ButtonRequest,
+    messages_ButtonAck as ButtonAck,
+    messages_Enum_PinMatrixRequestType as Enum_PinMatrixRequestType,
+    messages_PinMatrixRequestType as PinMatrixRequestType,
+    messages_PinMatrixRequest as PinMatrixRequest,
+    messages_PinMatrixAck as PinMatrixAck,
+    messages_PassphraseRequest as PassphraseRequest,
+    messages_PassphraseAck as PassphraseAck,
+    messages_Deprecated_PassphraseStateRequest as Deprecated_PassphraseStateRequest,
+    messages_Deprecated_PassphraseStateAck as Deprecated_PassphraseStateAck,
+    messages_CipherKeyValue as CipherKeyValue,
+    messages_CipheredKeyValue as CipheredKeyValue,
+    messages_IdentityType as IdentityType,
+    messages_SignIdentity as SignIdentity,
+    messages_SignedIdentity as SignedIdentity,
+    messages_GetECDHSessionKey as GetECDHSessionKey,
+    messages_ECDHSessionKey as ECDHSessionKey,
+    messages_DebugButton as DebugButton,
+    messages_EosGetPublicKey as EosGetPublicKey,
+    messages_EosPublicKey as EosPublicKey,
+    messages_EosTxHeader as EosTxHeader,
+    messages_EosSignTx as EosSignTx,
+    messages_EosTxActionRequest as EosTxActionRequest,
+    messages_EosAsset as EosAsset,
+    messages_EosPermissionLevel as EosPermissionLevel,
+    messages_EosAuthorizationKey as EosAuthorizationKey,
+    messages_EosAuthorizationAccount as EosAuthorizationAccount,
+    messages_EosAuthorizationWait as EosAuthorizationWait,
+    messages_EosAuthorization as EosAuthorization,
+    messages_EosActionCommon as EosActionCommon,
+    messages_EosActionTransfer as EosActionTransfer,
+    messages_EosActionDelegate as EosActionDelegate,
+    messages_EosActionUndelegate as EosActionUndelegate,
+    messages_EosActionRefund as EosActionRefund,
+    messages_EosActionBuyRam as EosActionBuyRam,
+    messages_EosActionBuyRamBytes as EosActionBuyRamBytes,
+    messages_EosActionSellRam as EosActionSellRam,
+    messages_EosActionVoteProducer as EosActionVoteProducer,
+    messages_EosActionUpdateAuth as EosActionUpdateAuth,
+    messages_EosActionDeleteAuth as EosActionDeleteAuth,
+    messages_EosActionLinkAuth as EosActionLinkAuth,
+    messages_EosActionUnlinkAuth as EosActionUnlinkAuth,
+    messages_EosActionNewAccount as EosActionNewAccount,
+    messages_EosActionUnknown as EosActionUnknown,
+    messages_EosTxActionAck as EosTxActionAck,
+    messages_EosSignedTx as EosSignedTx,
+    messages_EthereumSignTypedData as EthereumSignTypedData,
+    messages_EthereumTypedDataStructRequest as EthereumTypedDataStructRequest,
+    messages_EthereumDataType as EthereumDataType,
+    messages_EthereumFieldType as EthereumFieldType,
+    messages_EthereumStructMember as EthereumStructMember,
+    messages_EthereumTypedDataStructAck as EthereumTypedDataStructAck,
+    messages_EthereumTypedDataValueRequest as EthereumTypedDataValueRequest,
+    messages_EthereumTypedDataValueAck as EthereumTypedDataValueAck,
+    messages_EthereumGetPublicKey as EthereumGetPublicKey,
+    messages_EthereumPublicKey as EthereumPublicKey,
+    messages_EthereumGetAddress as EthereumGetAddress,
+    messages_EthereumAddress as EthereumAddress,
+    messages_EthereumSignTx as EthereumSignTx,
+    messages_EthereumAccessList as EthereumAccessList,
+    messages_EthereumSignTxEIP1559 as EthereumSignTxEIP1559,
+    messages_EthereumTxRequest as EthereumTxRequest,
+    messages_EthereumTxAck as EthereumTxAck,
+    messages_EthereumSignMessage as EthereumSignMessage,
+    messages_EthereumSignMessageEIP712 as EthereumSignMessageEIP712,
+    messages_EthereumMessageSignature as EthereumMessageSignature,
+    messages_EthereumVerifyMessage as EthereumVerifyMessage,
+    messages_EthereumSignTypedHash as EthereumSignTypedHash,
+    messages_EthereumTypedDataSignature as EthereumTypedDataSignature,
+    messages_Enum_BackupType as Enum_BackupType,
+    messages_BackupType as BackupType,
+    messages_Enum_SafetyCheckLevel as Enum_SafetyCheckLevel,
+    messages_SafetyCheckLevel as SafetyCheckLevel,
+    messages_Initialize as Initialize,
+    messages_GetFeatures as GetFeatures,
+    messages_Enum_Capability as Enum_Capability,
+    messages_Capability as Capability,
+    messages_Features as Features,
+    messages_LockDevice as LockDevice,
+    messages_EndSession as EndSession,
+    messages_ApplySettings as ApplySettings,
+    messages_ApplyFlags as ApplyFlags,
+    messages_ChangePin as ChangePin,
+    messages_ChangeWipeCode as ChangeWipeCode,
+    messages_SdProtectOperationType as SdProtectOperationType,
+    messages_SdProtect as SdProtect,
+    messages_Ping as Ping,
+    messages_Cancel as Cancel,
+    messages_GetEntropy as GetEntropy,
+    messages_Entropy as Entropy,
+    messages_GetFirmwareHash as GetFirmwareHash,
+    messages_FirmwareHash as FirmwareHash,
+    messages_GetFirmware as GetFirmware,
+    messages_FirmwareChunk as FirmwareChunk,
+    messages_FirmwareChunkAck as FirmwareChunkAck,
+    messages_WipeDevice as WipeDevice,
+    messages_ResetDevice as ResetDevice,
+    messages_BackupDevice as BackupDevice,
+    messages_EntropyRequest as EntropyRequest,
+    messages_EntropyAck as EntropyAck,
+    messages_RecoveryDeviceType as RecoveryDeviceType,
+    messages_RecoveryDevice as RecoveryDevice,
+    messages_Enum_WordRequestType as Enum_WordRequestType,
+    messages_WordRequestType as WordRequestType,
+    messages_WordRequest as WordRequest,
+    messages_WordAck as WordAck,
+    messages_SetU2FCounter as SetU2FCounter,
+    messages_GetNextU2FCounter as GetNextU2FCounter,
+    messages_NextU2FCounter as NextU2FCounter,
+    messages_DoPreauthorized as DoPreauthorized,
+    messages_PreauthorizedRequest as PreauthorizedRequest,
+    messages_CancelAuthorization as CancelAuthorization,
+    messages_BixinReboot as BixinReboot,
+    messages_RebootToBootloader as RebootToBootloader,
+    messages_GetNonce as GetNonce,
+    messages_Nonce as Nonce,
+    messages_NEMGetAddress as NEMGetAddress,
+    messages_NEMAddress as NEMAddress,
+    messages_NEMTransactionCommon as NEMTransactionCommon,
+    messages_NEMMosaic as NEMMosaic,
+    messages_NEMTransfer as NEMTransfer,
+    messages_NEMProvisionNamespace as NEMProvisionNamespace,
+    messages_NEMMosaicLevy as NEMMosaicLevy,
+    messages_NEMMosaicDefinition as NEMMosaicDefinition,
+    messages_NEMMosaicCreation as NEMMosaicCreation,
+    messages_NEMSupplyChangeType as NEMSupplyChangeType,
+    messages_NEMMosaicSupplyChange as NEMMosaicSupplyChange,
+    messages_NEMModificationType as NEMModificationType,
+    messages_NEMCosignatoryModification as NEMCosignatoryModification,
+    messages_NEMAggregateModification as NEMAggregateModification,
+    messages_NEMImportanceTransferMode as NEMImportanceTransferMode,
+    messages_NEMImportanceTransfer as NEMImportanceTransfer,
+    messages_NEMSignTx as NEMSignTx,
+    messages_NEMSignedTx as NEMSignedTx,
+    messages_NEMDecryptMessage as NEMDecryptMessage,
+    messages_NEMDecryptedMessage as NEMDecryptedMessage,
+    messages_RippleGetAddress as RippleGetAddress,
+    messages_RippleAddress as RippleAddress,
+    messages_RipplePayment as RipplePayment,
+    messages_RippleSignTx as RippleSignTx,
+    messages_RippleSignedTx as RippleSignedTx,
+    messages_StellarAssetType as StellarAssetType,
+    messages_StellarAsset as StellarAsset,
+    messages_StellarGetAddress as StellarGetAddress,
+    messages_StellarAddress as StellarAddress,
+    messages_StellarMemoType as StellarMemoType,
+    messages_StellarSignTx as StellarSignTx,
+    messages_StellarTxOpRequest as StellarTxOpRequest,
+    messages_StellarPaymentOp as StellarPaymentOp,
+    messages_StellarCreateAccountOp as StellarCreateAccountOp,
+    messages_StellarPathPaymentStrictReceiveOp as StellarPathPaymentStrictReceiveOp,
+    messages_StellarPathPaymentStrictSendOp as StellarPathPaymentStrictSendOp,
+    messages_StellarManageSellOfferOp as StellarManageSellOfferOp,
+    messages_StellarManageBuyOfferOp as StellarManageBuyOfferOp,
+    messages_StellarCreatePassiveSellOfferOp as StellarCreatePassiveSellOfferOp,
+    messages_StellarSignerType as StellarSignerType,
+    messages_StellarSetOptionsOp as StellarSetOptionsOp,
+    messages_StellarChangeTrustOp as StellarChangeTrustOp,
+    messages_StellarAllowTrustOp as StellarAllowTrustOp,
+    messages_StellarAccountMergeOp as StellarAccountMergeOp,
+    messages_StellarManageDataOp as StellarManageDataOp,
+    messages_StellarBumpSequenceOp as StellarBumpSequenceOp,
+    messages_StellarSignedTx as StellarSignedTx,
+    messages_TezosGetAddress as TezosGetAddress,
+    messages_TezosAddress as TezosAddress,
+    messages_TezosGetPublicKey as TezosGetPublicKey,
+    messages_TezosPublicKey as TezosPublicKey,
+    messages_TezosContractType as TezosContractType,
+    messages_TezosContractID as TezosContractID,
+    messages_TezosRevealOp as TezosRevealOp,
+    messages_TezosManagerTransfer as TezosManagerTransfer,
+    messages_TezosParametersManager as TezosParametersManager,
+    messages_TezosTransactionOp as TezosTransactionOp,
+    messages_TezosOriginationOp as TezosOriginationOp,
+    messages_TezosDelegationOp as TezosDelegationOp,
+    messages_TezosProposalOp as TezosProposalOp,
+    messages_TezosBallotType as TezosBallotType,
+    messages_TezosBallotOp as TezosBallotOp,
+    messages_TezosSignTx as TezosSignTx,
+    messages_TezosSignedTx as TezosSignedTx,
+    messages_MessageType as MessageType,
+    messages_MessageKey as MessageKey,
+    messages_MessageResponse as MessageResponse,
+    messages_TypedCall as TypedCall,
+  };
+}
+
+declare function info(res: any): {
+    version: string;
+    configured: boolean;
+};
+declare function version(version: any): string;
+declare function devices(res: any): Array<OneKeyDeviceInfoWithSession>;
+declare function acquire(res: any): string;
+declare function call(res: any): MessageFromOneKey;
+
+declare const check_info: typeof info;
+declare const check_version: typeof version;
+declare const check_devices: typeof devices;
+declare const check_acquire: typeof acquire;
+declare const check_call: typeof call;
+declare namespace check {
+  export {
+    check_info as info,
+    check_version as version,
+    check_devices as devices,
+    check_acquire as acquire,
+    check_call as call,
+  };
+}
+
+declare const MESSAGE_TOP_CHAR = 63;
+declare const MESSAGE_HEADER_BYTE = 35;
+declare const HEADER_SIZE: number;
+declare const BUFFER_SIZE = 63;
+
+declare const _default: {
+    check: typeof check;
+    buildOne: typeof buildOne;
+    buildBuffer: (messages: protobuf.Root, name: string, data: Record<string, unknown>) => ByteBuffer;
+    receiveOne: typeof receiveOne;
+    parseConfigure: typeof parseConfigure;
+};
+
+export { AcquireInput, BUFFER_SIZE, HEADER_SIZE, MESSAGE_HEADER_BYTE, MESSAGE_TOP_CHAR, MessageFromOneKey, messages as Messages, OneKeyDeviceInfo, OneKeyDeviceInfoWithSession, OneKeyMobileDeviceInfo, Transport, _default as default };