import { AminoMsg as AminoMsg$1, StdSignDoc, AminoSignResponse, StdFee as StdFee$1, coin as coin$1, coins as coins$1, parseCoins as parseCoins$1, addCoins as addCoins$1, StdSignature, OfflineAminoSigner, Algo as Algo$1 } from '@cosmjs/amino';
import { DeliverTxResponse } from '@cosmjs/stargate';
import { OfflineDirectSigner, AccountData, OfflineSigner, GeneratedType, DirectSignResponse } from '@cosmjs/proto-signing';
import { SignDoc } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
import Long from 'long';

type CosmosMsg = {
    typeUrl: string;
    value: any;
};
type AminoMsg = {
    type: string;
    value: any;
};
type ProtoMsg = {
    typeUrl: string;
    value: Uint8Array;
};
declare class TransactionMsg<T = any> {
    typeUrl: string;
    aminoTypeUrl: string;
    value: T;
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor(typeUrl: string, aminoTypeUrl: string, value: T);
    toCosmosMsg(): CosmosMsg;
    toAminoMsg(): AminoMsg;
    toProtoMsg(): ProtoMsg;
    toTerraExtensionMsg(): string;
}

type MsgExecuteContractValue = {
    sender: string;
    contract: string;
    msg: any;
    funds?: Coin[];
};
declare class MsgExecuteContract extends TransactionMsg<MsgExecuteContractValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ sender, contract, msg, funds }: MsgExecuteContractValue);
    toCosmosMsg(): CosmosMsg;
    toProtoMsg(): ProtoMsg;
}

type BasicAllowanceValue = {
    spendLimit: Coin[];
    expiration?: string;
};
declare class BasicAllowance extends TransactionMsg<BasicAllowanceValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ spendLimit, expiration }: BasicAllowanceValue);
    toTerraExtensionMsg(): string;
    toAminoMsg(): AminoMsg;
    toProtoMsg(): ProtoMsg;
}

type MsgGrantAllowanceValue = {
    granter: string;
    grantee: string;
    allowance: BasicAllowanceValue;
};
declare class MsgGrantAllowance extends TransactionMsg<MsgGrantAllowanceValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ granter, grantee, allowance }: MsgGrantAllowanceValue);
    toCosmosMsg(): CosmosMsg;
    toTerraExtensionMsg(): any;
    toAminoMsg(): AminoMsg;
    toProtoMsg(): ProtoMsg;
}

type MsgRevokeAllowanceValue = {
    granter: string;
    grantee: string;
};
declare class MsgRevokeAllowance extends TransactionMsg<MsgRevokeAllowanceValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ granter, grantee }: MsgRevokeAllowanceValue);
    toProtoMsg(): ProtoMsg;
}

type MsgSendValue = {
    fromAddress: string;
    toAddress: string;
    amount: Coin[];
};
declare class MsgSend extends TransactionMsg<MsgSendValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ fromAddress, toAddress, amount }: MsgSendValue);
    toTerraExtensionMsg(): string;
    toAminoMsg(): AminoMsg;
    toProtoMsg(): ProtoMsg;
}

type MsgTransferValue = {
    sender: string;
    receiver: string;
    sourcePort: string;
    sourceChannel: string;
    token?: Coin;
    timeoutHeight?: {
        revisionNumber: string;
        revisionHeight: string;
    };
    timeoutTimestamp?: string;
    memo?: string;
};
declare class MsgTransfer extends TransactionMsg<MsgTransferValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ sender, receiver, sourcePort, sourceChannel, token, timeoutHeight, timeoutTimestamp, memo, }: MsgTransferValue);
    toTerraExtensionMsg(): string;
    toAminoMsg(): AminoMsg;
    toProtoMsg(): ProtoMsg;
}

type MsgAllianceDelegateValue = {
    delegatorAddress: string;
    validatorAddress: string;
    amount: Coin;
};
declare class MsgAllianceDelegate extends TransactionMsg<MsgAllianceDelegateValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ delegatorAddress, validatorAddress, amount }: MsgAllianceDelegateValue);
    toTerraExtensionMsg(): string;
    toAminoMsg(): AminoMsg;
    toProtoMsg(): ProtoMsg;
}

type MsgInstantiateContractValue = {
    sender: string;
    admin?: string;
    codeId: string;
    label?: string;
    msg: any;
    funds?: Coin[];
};
declare class MsgInstantiateContract extends TransactionMsg<MsgInstantiateContractValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ sender, admin, codeId, label, msg, funds }: MsgInstantiateContractValue);
    toTerraExtensionMsg(): string;
    toAminoMsg(): AminoMsg;
    toCosmosMsg(): CosmosMsg;
    toProtoMsg(): ProtoMsg;
}

type MsgMigrateContractValue = {
    sender: string;
    contract: string;
    codeId: string;
    msg: any;
};
declare class MsgMigrateContract extends TransactionMsg<MsgMigrateContractValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ sender, contract, codeId, msg }: MsgMigrateContractValue);
    toTerraExtensionMsg(): string;
    toAminoMsg(): AminoMsg;
    toCosmosMsg(): CosmosMsg;
    toProtoMsg(): ProtoMsg;
}

type MsgCreateSpotLimitOrderValue = {
    sender: string;
    order: {
        subaccountId: string;
        marketId: string;
        feeRecipient: string;
        price: string;
        quantity: string;
        orderType: number;
    };
};
declare class MsgCreateSpotLimitOrder extends TransactionMsg<MsgCreateSpotLimitOrderValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ sender, order }: MsgCreateSpotLimitOrderValue);
    toCosmosMsg(): CosmosMsg;
    toProtoMsg(): ProtoMsg;
}

type MsgCancelSpotOrderValue = {
    sender: string;
    market_id: string;
    subaccount_id: string;
    order_hash: string;
};
declare class MsgCancelSpotOrder extends TransactionMsg<MsgCancelSpotOrderValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ sender, market_id, subaccount_id, order_hash }: MsgCancelSpotOrderValue);
    toCosmosMsg(): CosmosMsg;
    toProtoMsg(): ProtoMsg;
}

type MsgDepositForBurnValue = {
    from: string;
    amount: string;
    destinationDomain: number;
    mintRecipient: Uint8Array;
    burnToken: string;
};
declare class MsgDepositForBurn extends TransactionMsg<MsgDepositForBurnValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ from, amount, destinationDomain, mintRecipient, burnToken }: MsgDepositForBurnValue);
    toTerraExtensionMsg(): string;
    toAminoMsg(): AminoMsg$1;
    toProtoMsg(): ProtoMsg;
}

declare enum WireType {
    Varint = 0,
    Fixed64 = 1,
    Bytes = 2,
    Fixed32 = 5
}
interface IBinaryReader {
    buf: Uint8Array;
    pos: number;
    type: number;
    len: number;
    tag(): [number, WireType, number];
    skip(length?: number): this;
    skipType(wireType: number): this;
    uint32(): number;
    int32(): number;
    sint32(): number;
    fixed32(): number;
    sfixed32(): number;
    int64(): bigint;
    uint64(): bigint;
    sint64(): bigint;
    fixed64(): bigint;
    sfixed64(): bigint;
    float(): number;
    double(): number;
    bool(): boolean;
    bytes(): Uint8Array;
    string(): string;
}
declare class BinaryReader implements IBinaryReader {
    buf: Uint8Array;
    pos: number;
    type: number;
    len: number;
    assertBounds(): void;
    constructor(buf?: ArrayLike<number>);
    tag(): [number, WireType, number];
    skip(length?: number): this;
    skipType(wireType: number): this;
    uint32(): number;
    int32(): number;
    sint32(): number;
    fixed32(): number;
    sfixed32(): number;
    int64(): bigint;
    uint64(): bigint;
    sint64(): bigint;
    fixed64(): bigint;
    sfixed64(): bigint;
    float(): number;
    double(): number;
    bool(): boolean;
    bytes(): Uint8Array;
    string(): string;
}
interface IBinaryWriter {
    len: number;
    head: IOp;
    tail: IOp;
    states: State | null;
    finish(): Uint8Array;
    fork(): IBinaryWriter;
    reset(): IBinaryWriter;
    ldelim(): IBinaryWriter;
    tag(fieldNo: number, type: WireType): IBinaryWriter;
    uint32(value: number): IBinaryWriter;
    int32(value: number): IBinaryWriter;
    sint32(value: number): IBinaryWriter;
    int64(value: string | number | bigint): IBinaryWriter;
    uint64: (value: string | number | bigint) => IBinaryWriter;
    sint64(value: string | number | bigint): IBinaryWriter;
    fixed64(value: string | number | bigint): IBinaryWriter;
    sfixed64: (value: string | number | bigint) => IBinaryWriter;
    bool(value: boolean): IBinaryWriter;
    fixed32(value: number): IBinaryWriter;
    sfixed32: (value: number) => IBinaryWriter;
    float(value: number): IBinaryWriter;
    double(value: number): IBinaryWriter;
    bytes(value: Uint8Array): IBinaryWriter;
    string(value: string): IBinaryWriter;
}
interface IOp {
    len: number;
    next?: IOp;
    proceed(buf: Uint8Array | number[], pos: number): void;
}
declare class State {
    head: IOp;
    tail: IOp;
    len: number;
    next: State | null;
    constructor(writer: BinaryWriter);
}
declare class BinaryWriter implements IBinaryWriter {
    len: number;
    head: IOp;
    tail: IOp;
    states: State | null;
    constructor();
    static create(): BinaryWriter;
    static alloc(size: number): Uint8Array | number[];
    private _push;
    finish(): Uint8Array;
    fork(): BinaryWriter;
    reset(): BinaryWriter;
    ldelim(): BinaryWriter;
    tag(fieldNo: number, type: WireType): BinaryWriter;
    uint32(value: number): BinaryWriter;
    int32(value: number): BinaryWriter;
    sint32(value: number): BinaryWriter;
    int64(value: string | number | bigint): BinaryWriter;
    uint64: (value: string | number | bigint) => BinaryWriter;
    sint64(value: string | number | bigint): BinaryWriter;
    fixed64(value: string | number | bigint): BinaryWriter;
    sfixed64: (value: string | number | bigint) => BinaryWriter;
    bool(value: boolean): BinaryWriter;
    fixed32(value: number): BinaryWriter;
    sfixed32: (value: number) => BinaryWriter;
    float(value: number): BinaryWriter;
    double(value: number): BinaryWriter;
    bytes(value: Uint8Array): BinaryWriter;
    string(value: string): BinaryWriter;
}

interface DurationProtoMsg {
    typeUrl: "/google.protobuf.Duration";
    value: Uint8Array;
}
/**
 * A Duration represents a signed, fixed-length span of time represented
 * as a count of seconds and fractions of seconds at nanosecond
 * resolution. It is independent of any calendar and concepts like "day"
 * or "month". It is related to Timestamp in that the difference between
 * two Timestamp values is a Duration and it can be added or subtracted
 * from a Timestamp. Range is approximately +-10,000 years.
 *
 * # Examples
 *
 * Example 1: Compute Duration from two Timestamps in pseudo code.
 *
 *     Timestamp start = ...;
 *     Timestamp end = ...;
 *     Duration duration = ...;
 *
 *     duration.seconds = end.seconds - start.seconds;
 *     duration.nanos = end.nanos - start.nanos;
 *
 *     if (duration.seconds < 0 && duration.nanos > 0) {
 *       duration.seconds += 1;
 *       duration.nanos -= 1000000000;
 *     } else if (durations.seconds > 0 && duration.nanos < 0) {
 *       duration.seconds -= 1;
 *       duration.nanos += 1000000000;
 *     }
 *
 * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
 *
 *     Timestamp start = ...;
 *     Duration duration = ...;
 *     Timestamp end = ...;
 *
 *     end.seconds = start.seconds + duration.seconds;
 *     end.nanos = start.nanos + duration.nanos;
 *
 *     if (end.nanos < 0) {
 *       end.seconds -= 1;
 *       end.nanos += 1000000000;
 *     } else if (end.nanos >= 1000000000) {
 *       end.seconds += 1;
 *       end.nanos -= 1000000000;
 *     }
 *
 * Example 3: Compute Duration from datetime.timedelta in Python.
 *
 *     td = datetime.timedelta(days=3, minutes=10)
 *     duration = Duration()
 *     duration.FromTimedelta(td)
 *
 * # JSON Mapping
 *
 * In JSON format, the Duration type is encoded as a string rather than an
 * object, where the string ends in the suffix "s" (indicating seconds) and
 * is preceded by the number of seconds, with nanoseconds expressed as
 * fractional seconds. For example, 3 seconds with 0 nanoseconds should be
 * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
 * be expressed in JSON format as "3.000000001s", and 3 seconds and 1
 * microsecond should be expressed in JSON format as "3.000001s".
 */
type DurationAmino = string;
interface DurationAminoMsg {
    type: "/google.protobuf.Duration";
    value: DurationAmino;
}
/**
 * A Duration represents a signed, fixed-length span of time represented
 * as a count of seconds and fractions of seconds at nanosecond
 * resolution. It is independent of any calendar and concepts like "day"
 * or "month". It is related to Timestamp in that the difference between
 * two Timestamp values is a Duration and it can be added or subtracted
 * from a Timestamp. Range is approximately +-10,000 years.
 *
 * # Examples
 *
 * Example 1: Compute Duration from two Timestamps in pseudo code.
 *
 *     Timestamp start = ...;
 *     Timestamp end = ...;
 *     Duration duration = ...;
 *
 *     duration.seconds = end.seconds - start.seconds;
 *     duration.nanos = end.nanos - start.nanos;
 *
 *     if (duration.seconds < 0 && duration.nanos > 0) {
 *       duration.seconds += 1;
 *       duration.nanos -= 1000000000;
 *     } else if (durations.seconds > 0 && duration.nanos < 0) {
 *       duration.seconds -= 1;
 *       duration.nanos += 1000000000;
 *     }
 *
 * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
 *
 *     Timestamp start = ...;
 *     Duration duration = ...;
 *     Timestamp end = ...;
 *
 *     end.seconds = start.seconds + duration.seconds;
 *     end.nanos = start.nanos + duration.nanos;
 *
 *     if (end.nanos < 0) {
 *       end.seconds -= 1;
 *       end.nanos += 1000000000;
 *     } else if (end.nanos >= 1000000000) {
 *       end.seconds += 1;
 *       end.nanos -= 1000000000;
 *     }
 *
 * Example 3: Compute Duration from datetime.timedelta in Python.
 *
 *     td = datetime.timedelta(days=3, minutes=10)
 *     duration = Duration()
 *     duration.FromTimedelta(td)
 *
 * # JSON Mapping
 *
 * In JSON format, the Duration type is encoded as a string rather than an
 * object, where the string ends in the suffix "s" (indicating seconds) and
 * is preceded by the number of seconds, with nanoseconds expressed as
 * fractional seconds. For example, 3 seconds with 0 nanoseconds should be
 * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
 * be expressed in JSON format as "3.000000001s", and 3 seconds and 1
 * microsecond should be expressed in JSON format as "3.000001s".
 */
interface Duration {
    /**
     * Signed seconds of the span of time. Must be from -315,576,000,000
     * to +315,576,000,000 inclusive. Note: these bounds are computed from:
     * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
     */
    seconds: bigint;
    /**
     * Signed fractions of a second at nanosecond resolution of the span
     * of time. Durations less than one second are represented with a 0
     * `seconds` field and a positive or negative `nanos` field. For durations
     * of one second or more, a non-zero value for the `nanos` field must be
     * of the same sign as the `seconds` field. Must be from -999,999,999
     * to +999,999,999 inclusive.
     */
    nanos: number;
}
declare const Duration: {
    typeUrl: string;
    encode(message: Duration, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Duration;
    fromPartial(object: Partial<Duration>): Duration;
    fromAmino(object: DurationAmino): Duration;
    toAmino(message: Duration): DurationAmino;
    fromAminoMsg(object: DurationAminoMsg): Duration;
    fromProtoMsg(message: DurationProtoMsg): Duration;
    toProto(message: Duration): Uint8Array;
    toProtoMsg(message: Duration): DurationProtoMsg;
};

interface CoinProtoMsg {
    typeUrl: "/cosmos.base.v1beta1.Coin";
    value: Uint8Array;
}
/**
 * Coin defines a token with a denomination and an amount.
 *
 * NOTE: The amount field is an Int which implements the custom method
 * signatures required by gogoproto.
 */
interface CoinAmino {
    denom?: string;
    amount?: string;
}
interface CoinAminoMsg {
    type: "cosmos-sdk/Coin";
    value: CoinAmino;
}
/**
 * Coin defines a token with a denomination and an amount.
 *
 * NOTE: The amount field is an Int which implements the custom method
 * signatures required by gogoproto.
 */
interface Coin$1 {
    denom: string;
    amount: string;
}
declare const Coin$1: {
    typeUrl: string;
    encode(message: Coin$1, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Coin$1;
    fromPartial(object: Partial<Coin$1>): Coin$1;
    fromAmino(object: CoinAmino): Coin$1;
    toAmino(message: Coin$1): CoinAmino;
    fromAminoMsg(object: CoinAminoMsg): Coin$1;
    toAminoMsg(message: Coin$1): CoinAminoMsg;
    fromProtoMsg(message: CoinProtoMsg): Coin$1;
    toProto(message: Coin$1): Uint8Array;
    toProtoMsg(message: Coin$1): CoinProtoMsg;
};

type MsgLockTokensValue = {
    owner: string;
    duration: Duration;
    coins: Coin$1[];
};
declare class MsgLockTokens extends TransactionMsg<MsgLockTokensValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ owner, duration, coins }: MsgLockTokensValue);
    toAminoMsg(): AminoMsg;
    toProtoMsg(): ProtoMsg;
}

type MsgBeginUnlockingValue = {
    owner: string;
    ID: Long;
    coins?: Coin$1[];
};
declare class MsgBeginUnlocking extends TransactionMsg<MsgBeginUnlockingValue> {
    static TYPE: string;
    static AMINO_TYPE: string;
    constructor({ owner, ID, coins }: MsgBeginUnlockingValue);
    toAminoMsg(): AminoMsg;
    toProtoMsg(): ProtoMsg;
}

type SimulateResultSuccess = {
    success: true;
    fee: Fee;
};
type SimulateResultError = {
    success: false;
    error: string;
};
type SimulateResult = SimulateResultSuccess | SimulateResultError;
type BroadcastResult = {
    hash: string;
    /**
     * A string-based log document.
     *
     * This currently seems to merge attributes of multiple events into one event per type
     * (https://github.com/tendermint/tendermint/issues/9595). You might want to use the `events`
     * field instead.
     *
     * @deprecated This field is not filled anymore in Cosmos SDK 0.50+ (https://github.com/cosmos/cosmos-sdk/pull/15845).
     * Please consider using `events` instead.
     */
    rawLogs: DeliverTxResponse["rawLog"];
    events: DeliverTxResponse["events"];
    response: any;
};
declare enum EthSignType {
    MESSAGE = "message",
    TRANSACTION = "transaction",
    EIP712 = "eip-712"
}
type SigningResult = {
    signatures: Uint8Array[];
    response: any;
};

type BIP44 = {
    coinType: number;
};
type Bech32Config = {
    bech32PrefixAccAddr: string;
    bech32PrefixAccPub: string;
    bech32PrefixValAddr: string;
    bech32PrefixValPub: string;
    bech32PrefixConsAddr: string;
    bech32PrefixConsPub: string;
};
type NetworkCurrency = {
    coinDenom: string;
    coinMinimalDenom: string;
    coinDecimals: number;
    coinGeckoId?: string;
    gasPriceStep?: {
        low: number;
        average: number;
        high: number;
    };
};
type Network = {
    name: string;
    chainId: string;
    chainPrefix?: string;
    rpc: string;
    rest: string;
    gasPrice?: string;
    bip44?: BIP44;
    defaultCurrency?: NetworkCurrency;
    stakeCurrency?: NetworkCurrency;
    feeCurrencies?: NetworkCurrency[];
    features?: string[];
    bech32Config?: Bech32Config;
    evm?: {
        deriveCosmosAddress: (address: string) => string;
        fromEthChainToCosmosChain: (chainId: number) => string;
    };
};
declare const DEFAULT_CHAIN_PREFIX = "cosmos";
declare const DEFAULT_BIP44_COIN_TYPE = 118;
declare const DEFAULT_CURRENCY: {
    coinDenom: string;
    coinMinimalDenom: string;
    coinDecimals: number;
    coinGeckoId: string;
};
declare const DEFAULT_GAS_PRICE: string;
declare const DEFAULT_GAS_MULTIPLIER = 1.5;
declare function isInjectiveNetwork(chainId: string): boolean;
declare function fromInjectiveCosmosChainToEthereumChain(chainId: string): number;
declare function fromInjectiveEthereumChainToCosmosChain(chainNumber: number): string;

type Algo = "secp256k1" | "ed25519" | "sr25519";
declare enum Algos {
    secp256k1 = "secp256k1",
    ed25519 = "ed25519",
    sr25519 = "sr25519"
}
type Account = {
    address: string;
    algo: Algo | null;
    pubkey: string | null;
    isLedger?: boolean;
};
type WalletConnection = {
    id: string;
    providerId: string;
    network: Network;
    account: Account;
    walletAccount?: Account;
    mobileSession: WalletMobileSession;
};
type WalletMobileSession = {
    walletConnectSession?: {
        topic: string;
        expiry: number;
    };
};

declare class AminoSigningClient {
    static prepare({ network, wallet, messages, fee, feeAmount, gasLimit, memo, overrides, }: {
        network: Network;
        wallet: WalletConnection;
        messages: TransactionMsg[];
        fee?: Fee | null;
        feeAmount?: string | null;
        gasLimit?: string | null;
        memo?: string | null;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<StdSignDoc>;
    static finish({ network, messages, signResponse, memo, }: {
        network: Network;
        messages: TransactionMsg[];
        signResponse: AminoSignResponse;
        memo?: string | null;
    }): Promise<SigningResult>;
}

declare function createEmptySignDoc(signer: string, data: Uint8Array): {
    chain_id: string;
    account_number: string;
    sequence: string;
    fee: {
        gas: string;
        amount: never[];
    };
    msgs: {
        type: string;
        value: {
            signer: string;
            data: string;
        };
    }[];
    memo: string;
};
declare class ArbitrarySigningClient {
    static prepareSigningWithMemo({ network, data }: {
        network: Network;
        data: Uint8Array;
    }): {
        chain_id: string;
        account_number: string;
        sequence: string;
        fee: {
            gas: string;
            amount: {
                denom: string;
                amount: string;
            }[];
        };
        msgs: never[];
        memo: string;
    };
    static verifyMemoSignature({ network, wallet, data, signature, }: {
        network: Network;
        wallet: WalletConnection;
        data: Uint8Array;
        signature: Uint8Array;
    }): Promise<boolean>;
    static verifyEmptyDocSignature({ wallet, data, signature, }: {
        wallet: WalletConnection;
        data: Uint8Array;
        signature: Uint8Array;
    }): Promise<boolean>;
    static verifyBytesSignature({ wallet, data, signature, }: {
        wallet: WalletConnection;
        data: Uint8Array;
        signature: Uint8Array;
    }): Promise<boolean>;
}

declare class BroadcastClient {
    static execute({ network, signResult, overrides, }: {
        network: Network;
        signResult: SigningResult;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<BroadcastResult>;
}

declare class FakeOfflineSigner implements OfflineDirectSigner {
    private readonly wallet;
    constructor(wallet: WalletConnection | null);
    getAccounts(): Promise<readonly AccountData[]>;
    signDirect(_signerAddress: string, _signDoc: any): Promise<any>;
}

declare class OfflineDirectSigningClient {
    static sign(offlineSigner: OfflineSigner & OfflineDirectSigner, { network, wallet, messages, fee, feeAmount, gasLimit, memo, overrides, }: {
        network: Network;
        wallet: WalletConnection;
        messages: TransactionMsg[];
        fee?: Fee | null;
        feeAmount?: string | null;
        gasLimit?: string | null;
        memo?: string | null;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<SigningResult>;
}

declare class SignAndBroadcastClient {
    static execute(offlineSigner: OfflineSigner & OfflineDirectSigner, { network, wallet, messages, fee, feeAmount, gasLimit, memo, overrides, }: {
        network: Network;
        wallet: WalletConnection;
        messages: TransactionMsg[];
        fee?: Fee | null;
        feeAmount?: string | null;
        gasLimit?: string | null;
        memo?: string | null;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<BroadcastResult>;
}

declare class SimulateClient {
    static run({ network, wallet, messages, overrides, }: {
        network: Network;
        wallet: WalletConnection;
        messages: TransactionMsg[];
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<SimulateResult>;
}

type StdFee = StdFee$1;
declare const coin: typeof coin$1;
declare const coins: typeof coins$1;
declare const parseCoins: typeof parseCoins$1;
declare const addCoins: typeof addCoins$1;
type Coin = {
    amount: string;
    denom: string;
};
type Fee = {
    amount: Coin[];
    gas: string;
};

type MobileConnectResponse = {
    qrCodeUrl: string;
    iosUrl: string;
    androidUrl: string;
};

declare const extendedRegistryTypes: ReadonlyArray<[string, GeneratedType]>;

declare abstract class WalletExtensionProvider {
    id: string;
    name: string;
    networks: Map<string, Network>;
    initializing: boolean;
    initialized: boolean;
    onUpdate?: () => void;
    signEthereum?: (options: {
        wallet: WalletConnection;
        data: string | Uint8Array;
        type: EthSignType;
    }) => Promise<SigningResult>;
    extensionProviderAdapter: ExtensionProviderAdapter;
    constructor({ id, name, networks, extensionProviderAdapter, }: {
        id: string;
        name: string;
        networks: Network[];
        extensionProviderAdapter: ExtensionProviderAdapter;
    });
    setOnUpdateCallback(callback: () => void): void;
    init(): Promise<void>;
    connect({ chainId }: {
        chainId: string;
    }): Promise<WalletConnection>;
    disconnect({ wallet }: {
        wallet: WalletConnection;
    }): Promise<void>;
    simulate({ messages, wallet, overrides, }: {
        messages: TransactionMsg[];
        wallet: WalletConnection;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<SimulateResult>;
    sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
        messages: TransactionMsg[];
        wallet: WalletConnection;
        fee?: Fee | null;
        feeAmount?: string | null;
        gasLimit?: string | null;
        memo?: string | null;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<SigningResult>;
    broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
        messages: TransactionMsg[];
        wallet: WalletConnection;
        fee?: Fee | null;
        feeAmount?: string | null;
        gasLimit?: string | null;
        memo?: string | null;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<BroadcastResult>;
    signArbitrary({ wallet, data }: {
        wallet: WalletConnection;
        data: Uint8Array;
    }): Promise<SigningResult>;
    verifyArbitrary({ wallet, data, signResult, }: {
        wallet: WalletConnection;
        data: Uint8Array;
        signResult: SigningResult;
    }): Promise<boolean>;
}

interface KeplrChainInfo extends Network {
    rpc: string;
    rest: string;
    chainId: string;
    chainName: string;
    bip44: BIP44;
    bech32Config: Bech32Config;
    stakeCurrency: NetworkCurrency;
    currencies: NetworkCurrency[];
    feeCurrencies: NetworkCurrency[];
    coinType?: number;
    gasPriceStep?: {
        low: number;
        average: number;
        high: number;
    };
    features?: string[];
}
interface KeplrKey {
    address: Uint8Array;
    algo: string;
    bech32Address: string;
    isKeystone: boolean;
    isNanoLedger: boolean;
    name: string;
    pubKey?: Uint8Array;
    pubkey?: Uint8Array;
}
type KeplrWindow = {
    experimentalSuggestChain(chainInfo: KeplrChainInfo): Promise<void>;
    enable(chainId: string): Promise<void>;
    getKey(chainId: string): Promise<KeplrKey>;
    experimentalSignEIP712CosmosTx_v0(chainId: string, signer: string, eip712: {
        types: Record<string, {
            name: string;
            type: string;
        }[] | undefined>;
        domain: Record<string, any>;
        primaryType: string;
    }, signDoc: StdSignDoc, signOptions?: unknown): Promise<AminoSignResponse>;
    signAmino(chainId: string, signer: string, signDoc: StdSignDoc, signOptions?: {
        preferNoSetFee?: boolean;
        preferNoSetMemo?: boolean;
    }): Promise<AminoSignResponse>;
    getOfflineSigner(chainId: string): OfflineSigner & OfflineDirectSigner;
    signArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<StdSignature>;
    verifyArbitrary(chainId: string, signer: string, data: string | Uint8Array, signature: StdSignature): Promise<boolean>;
    defaultOptions?: {
        sign?: {
            preferNoSetFee?: boolean;
            preferNoSetMemo?: boolean;
        };
    };
    signEthereum(chainId: string, signer: string, data: string | Uint8Array, type: EthSignType): Promise<Uint8Array>;
};

interface ExtensionProviderAdapter {
    init(provider: WalletExtensionProvider): Promise<void>;
    isReady(): boolean;
    connect(provider: WalletExtensionProvider, options: {
        network: Network;
    }): Promise<WalletConnection>;
    disconnect(provider: WalletExtensionProvider, options?: {
        network: Network;
        wallet: WalletConnection;
    }): Promise<void>;
    sign(provider: WalletExtensionProvider, options: {
        network: Network;
        messages: TransactionMsg[];
        wallet: WalletConnection;
        fee?: Fee | null;
        feeAmount?: string | null;
        gasLimit?: string | null;
        memo?: string | null;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<SigningResult>;
    signAndBroadcast(provider: WalletExtensionProvider, options: {
        network: Network;
        messages: TransactionMsg[];
        wallet: WalletConnection;
        fee?: Fee | null;
        feeAmount?: string | null;
        gasLimit?: string | null;
        memo?: string | null;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<BroadcastResult>;
    signArbitrary(provider: WalletExtensionProvider, options: {
        network: Network;
        wallet: WalletConnection;
        data: Uint8Array;
    }): Promise<SigningResult>;
    verifyArbitrary(provider: WalletExtensionProvider, options: {
        network: Network;
        wallet: WalletConnection;
        data: Uint8Array;
        signResult: SigningResult;
    }): Promise<boolean>;
}

declare global {
    interface Window {
        keplr?: KeplrWindow;
    }
}
declare const KeplrExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        leap?: KeplrWindow;
    }
}
declare const LeapCosmosExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        signEthereum: ({ wallet, data, type, }: {
            wallet: WalletConnection;
            data: Uint8Array | string;
            type: EthSignType;
        }) => Promise<SigningResult>;
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare const LeapMetamaskCosmosSnapExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

type StationAccount = {
    address: string;
    addresses: {
        [key: string]: string;
    };
    ledger: boolean;
    name: string;
    network: "mainnet" | "testnet";
    pubkey: {
        118: string;
        330: string;
        [key: number]: string;
    };
};
type StationWindow = {
    connect(chainId?: string): Promise<Omit<StationAccount, "pubkey">>;
    getPublicKey(chainId?: string): Promise<StationAccount>;
    sign(tx: {
        chainID: string;
        msgs: string[];
        fee?: string;
        memo?: string;
    }, purgeQueue?: boolean): Promise<{
        auth_info: {
            fee: {
                amount: {
                    amount: string;
                    denom: string;
                }[];
                gas_limit: string;
                granter: string;
                payer: string;
            };
            signer_infos: {
                mode_info: any;
                public_key: {
                    ["@type"]: string;
                    key: string;
                };
                sequence: string;
            }[];
        };
        body: {
            memo: string;
            messages: any[];
            timeout_height: string;
        };
        signatures: string[];
    }>;
    post(tx: {
        chainID: string;
        msgs: string[];
        fee?: string;
        memo?: string;
    }, purgeQueue?: boolean): Promise<{
        height: string | number;
        raw_log: string;
        txhash: string;
        code?: number | string;
        codespace?: string;
    }>;
    signBytes(bytes: string, purgeQueue?: boolean): Promise<{
        public_key: string;
        recid: number;
        signature: string;
    }>;
};

declare global {
    interface Window {
        station?: StationWindow;
    }
}
declare const StationExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        xfi?: {
            terra: any;
            keplr: KeplrWindow & {
                addListener?: (event: string, callback: () => void) => void;
            };
        };
    }
}
declare const XDEFICosmosExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

interface Cosmostation {
    cosmos: {
        on(event: string, callback: () => void): void;
    };
    providers: {
        keplr: KeplrWindow;
    };
}
declare global {
    interface Window {
        cosmostation?: Cosmostation;
    }
}
declare const CosmostationExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

type EthereumWindow = {
    isMetaMask?: boolean;
    request: (request: {
        method: string;
        params?: unknown[] | object;
    }) => Promise<unknown>;
    on: (event: string, callback: (data: any) => void) => void;
};

declare global {
    interface Window {
        ethereum?: EthereumWindow;
    }
}
declare const MetamaskExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        fin?: KeplrWindow;
    }
}
declare const FinExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        compass?: KeplrWindow;
    }
}
declare const CompassExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

interface VectisChainInfo extends Network {
    rpcUrl: string;
    restUrl: string;
    chainId: string;
    chainName: string;
    prettyName: string;
    bech32Prefix: string;
    bip44: BIP44;
    currencies: NetworkCurrency[];
    stakeCurrency: NetworkCurrency;
    feeCurrencies: NetworkCurrency[];
    features?: string[];
    isSuggested?: boolean;
    ecosystem?: string;
}
interface VectisKey {
    algo: Algo$1;
    name: string;
    pubKey: Uint8Array;
    address: string;
    isNanoLedger: boolean;
    isVectisAccount: boolean;
}
type VectisWindowCosmosProvider = {
    suggestChains(chainsInfo: VectisChainInfo[]): Promise<void>;
    enable(chainIds: string | string[]): Promise<void>;
    getKey(chainId: string): Promise<VectisKey>;
    signAmino(signerAddress: string, doc: StdSignDoc): Promise<AminoSignResponse>;
    signDirect(signerAddress: string, doc: SignDoc): Promise<DirectSignResponse>;
    getOfflineSignerAmino(chainId: string): OfflineAminoSigner;
    getOfflineSignerDirect(chainId: string): OfflineDirectSigner;
    getOfflineSigner(chainId: string): OfflineSigner;
};
type VectisWindow = {
    version: string;
    cosmos: VectisWindowCosmosProvider;
};

declare global {
    interface Window {
        vectis?: VectisWindow;
    }
}
declare const VectisCosmosExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        okxwallet?: {
            keplr?: KeplrWindow;
        };
    }
}
declare const OkxWalletExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        ninji?: KeplrWindow & {
            on: (event: string, callback: () => void) => void;
        };
    }
}
declare const NinjiExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        bitkeep?: {
            keplr: KeplrWindow;
        };
    }
}
declare const BitgetExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        owallet?: KeplrWindow;
    }
}
declare const OWalletCosmosExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare const CosmiframeExtensionProvider: {
    new ({ networks, allowedParentOrigins }: {
        networks: Network[];
        allowedParentOrigins: string[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        citadelone?: {
            keplr?: KeplrWindow;
        };
    }
}
declare const CitadelOneExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        safepal?: {
            keplr?: KeplrWindow;
        };
    }
}
declare const SafePalExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        imToken?: KeplrWindow;
    }
}
declare const imTokenExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        math?: {
            keplr?: KeplrWindow;
        };
    }
}
declare const MathExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        cypherwallet?: {
            keplr?: KeplrWindow;
        };
    }
}
declare const CypherWalletExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare global {
    interface Window {
        trustwallet?: {
            keplr?: KeplrWindow;
        };
    }
}
declare const TrustWalletExtensionProvider: {
    new ({ networks }: {
        networks: Network[];
    }): {
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        signEthereum?: ((options: {
            wallet: WalletConnection;
            data: string | Uint8Array;
            type: EthSignType;
        }) => Promise<SigningResult>) | undefined;
        extensionProviderAdapter: ExtensionProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(): Promise<void>;
        connect({ chainId }: {
            chainId: string;
        }): Promise<WalletConnection>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        simulate({ messages, wallet, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare abstract class WalletMobileProvider {
    id: string;
    name: string;
    networks: Map<string, Network>;
    initializing: boolean;
    initialized: boolean;
    onUpdate?: () => void;
    mobileProviderAdapter: MobileProviderAdapter;
    constructor({ id, name, networks, mobileProviderAdapter, }: {
        id: string;
        name: string;
        networks: Network[];
        mobileProviderAdapter: MobileProviderAdapter;
    });
    setOnUpdateCallback(callback: () => void): void;
    abstract generateIntents(uri?: string): {
        qrCodeUrl: string;
        iosUrl: string;
        androidUrl: string;
    };
    init(params: {
        walletConnectProjectId?: string;
    }): Promise<void>;
    connect({ chainId, callback, }: {
        chainId: string;
        callback?: ((walletConnection: WalletConnection) => void) | undefined;
    }): Promise<MobileConnectResponse>;
    disconnect({ wallet }: {
        wallet: WalletConnection;
    }): Promise<void>;
    getWalletConnection({ chainId, mobileSession, }: {
        chainId: string;
        mobileSession: WalletMobileSession;
    }): Promise<WalletConnection>;
    simulate({ messages, wallet, }: {
        messages: TransactionMsg[];
        wallet: WalletConnection;
    }): Promise<SimulateResult>;
    sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
        messages: TransactionMsg[];
        wallet: WalletConnection;
        fee?: Fee | null;
        feeAmount?: string | null;
        gasLimit?: string | null;
        memo?: string | null;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<SigningResult>;
    broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
        messages: TransactionMsg[];
        wallet: WalletConnection;
        fee?: Fee | null;
        feeAmount?: string | null;
        gasLimit?: string | null;
        memo?: string | null;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
    }): Promise<BroadcastResult>;
    signArbitrary({ wallet, data }: {
        wallet: WalletConnection;
        data: Uint8Array;
    }): Promise<SigningResult>;
    verifyArbitrary({ wallet, data, signResult, }: {
        wallet: WalletConnection;
        data: Uint8Array;
        signResult: SigningResult;
    }): Promise<boolean>;
}

interface MobileProviderAdapter {
    init(provider: WalletMobileProvider, params: {
        walletConnectProjectId?: string;
    }): Promise<void>;
    isReady(): boolean;
    isSessionExpired(mobileSession: WalletMobileSession): boolean;
    getWalletConnection(provider: WalletMobileProvider, options: {
        network: Network;
        mobileSession: WalletMobileSession;
    }): Promise<WalletConnection>;
    connect(provider: WalletMobileProvider, options: {
        network: Network;
        callback?: ((wallet: WalletConnection) => void) | undefined;
    }): Promise<string>;
    disconnect(provider: WalletMobileProvider, options: {
        network: Network;
        wallet: WalletConnection;
    }): Promise<void>;
    sign(provider: WalletMobileProvider, options: {
        network: Network;
        messages: TransactionMsg[];
        wallet: WalletConnection;
        fee?: Fee | null;
        feeAmount?: string | null;
        gasLimit?: string | null;
        memo?: string | null;
        overrides?: {
            rpc?: string;
            rest?: string;
            gasAdjustment?: number;
            gasPrice?: string;
            feeCurrency?: NetworkCurrency;
        };
        intents: {
            androidUrl: string;
            iosUrl: string;
        };
    }): Promise<SigningResult>;
    signArbitrary(provider: WalletMobileProvider, options: {
        network: Network;
        wallet: WalletConnection;
        data: Uint8Array;
        intents: {
            androidUrl: string;
            iosUrl: string;
        };
    }): Promise<SigningResult>;
    verifyArbitrary(provider: WalletMobileProvider, options: {
        network: Network;
        wallet: WalletConnection;
        data: Uint8Array;
        signResult: SigningResult;
    }): Promise<boolean>;
}

declare const BitgetMobileProvider: {
    new ({ networks, walletConnectProjectId }: {
        networks: Network[];
        walletConnectProjectId?: string | undefined;
    }): {
        generateIntents(uri?: string): {
            qrCodeUrl: string;
            iosUrl: string;
            androidUrl: string;
        };
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        mobileProviderAdapter: MobileProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(params: {
            walletConnectProjectId?: string | undefined;
        }): Promise<void>;
        connect({ chainId, callback, }: {
            chainId: string;
            callback?: ((walletConnection: WalletConnection) => void) | undefined;
        }): Promise<MobileConnectResponse>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        getWalletConnection({ chainId, mobileSession, }: {
            chainId: string;
            mobileSession: WalletMobileSession;
        }): Promise<WalletConnection>;
        simulate({ messages, wallet, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare const CosmostationMobileProvider: {
    new ({ networks, walletConnectProjectId }: {
        networks: Network[];
        walletConnectProjectId?: string | undefined;
    }): {
        generateIntents(uri?: string): {
            qrCodeUrl: string;
            iosUrl: string;
            androidUrl: string;
        };
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        mobileProviderAdapter: MobileProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(params: {
            walletConnectProjectId?: string | undefined;
        }): Promise<void>;
        connect({ chainId, callback, }: {
            chainId: string;
            callback?: ((walletConnection: WalletConnection) => void) | undefined;
        }): Promise<MobileConnectResponse>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        getWalletConnection({ chainId, mobileSession, }: {
            chainId: string;
            mobileSession: WalletMobileSession;
        }): Promise<WalletConnection>;
        simulate({ messages, wallet, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare const KeplrMobileProvider: {
    new ({ networks, walletConnectProjectId }: {
        networks: Network[];
        walletConnectProjectId?: string | undefined;
    }): {
        generateIntents(uri?: string): {
            qrCodeUrl: string;
            iosUrl: string;
            androidUrl: string;
        };
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        mobileProviderAdapter: MobileProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(params: {
            walletConnectProjectId?: string | undefined;
        }): Promise<void>;
        connect({ chainId, callback, }: {
            chainId: string;
            callback?: ((walletConnection: WalletConnection) => void) | undefined;
        }): Promise<MobileConnectResponse>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        getWalletConnection({ chainId, mobileSession, }: {
            chainId: string;
            mobileSession: WalletMobileSession;
        }): Promise<WalletConnection>;
        simulate({ messages, wallet, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare const LeapCosmosMobileProvider: {
    new ({ networks, walletConnectProjectId }: {
        networks: Network[];
        walletConnectProjectId?: string | undefined;
    }): {
        generateIntents(uri?: string): {
            qrCodeUrl: string;
            iosUrl: string;
            androidUrl: string;
        };
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        mobileProviderAdapter: MobileProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(params: {
            walletConnectProjectId?: string | undefined;
        }): Promise<void>;
        connect({ chainId, callback, }: {
            chainId: string;
            callback?: ((walletConnection: WalletConnection) => void) | undefined;
        }): Promise<MobileConnectResponse>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        getWalletConnection({ chainId, mobileSession, }: {
            chainId: string;
            mobileSession: WalletMobileSession;
        }): Promise<WalletConnection>;
        simulate({ messages, wallet, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare const MetamaskMobileProvider: {
    new ({ networks, walletConnectProjectId }: {
        networks: Network[];
        walletConnectProjectId?: string | undefined;
    }): {
        generateIntents(uri?: string): {
            qrCodeUrl: string;
            iosUrl: string;
            androidUrl: string;
        };
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        mobileProviderAdapter: MobileProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(params: {
            walletConnectProjectId?: string | undefined;
        }): Promise<void>;
        connect({ chainId, callback, }: {
            chainId: string;
            callback?: ((walletConnection: WalletConnection) => void) | undefined;
        }): Promise<MobileConnectResponse>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        getWalletConnection({ chainId, mobileSession, }: {
            chainId: string;
            mobileSession: WalletMobileSession;
        }): Promise<WalletConnection>;
        simulate({ messages, wallet, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare const OnseiMobileProvider: {
    new ({ networks, walletConnectProjectId }: {
        networks: Network[];
        walletConnectProjectId?: string | undefined;
    }): {
        generateIntents(uri?: string): {
            qrCodeUrl: string;
            iosUrl: string;
            androidUrl: string;
        };
        id: string;
        name: string;
        networks: Map<string, Network>;
        initializing: boolean;
        initialized: boolean;
        onUpdate?: (() => void) | undefined;
        mobileProviderAdapter: MobileProviderAdapter;
        setOnUpdateCallback(callback: () => void): void;
        init(params: {
            walletConnectProjectId?: string | undefined;
        }): Promise<void>;
        connect({ chainId, callback, }: {
            chainId: string;
            callback?: ((walletConnection: WalletConnection) => void) | undefined;
        }): Promise<MobileConnectResponse>;
        disconnect({ wallet }: {
            wallet: WalletConnection;
        }): Promise<void>;
        getWalletConnection({ chainId, mobileSession, }: {
            chainId: string;
            mobileSession: WalletMobileSession;
        }): Promise<WalletConnection>;
        simulate({ messages, wallet, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
        }): Promise<SimulateResult>;
        sign({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<SigningResult>;
        broadcast({ messages, wallet, fee, feeAmount, gasLimit, memo, overrides, }: {
            messages: TransactionMsg<any>[];
            wallet: WalletConnection;
            fee?: Fee | null | undefined;
            feeAmount?: string | null | undefined;
            gasLimit?: string | null | undefined;
            memo?: string | null | undefined;
            overrides?: {
                rpc?: string | undefined;
                rest?: string | undefined;
                gasAdjustment?: number | undefined;
                gasPrice?: string | undefined;
                feeCurrency?: NetworkCurrency | undefined;
            } | undefined;
        }): Promise<BroadcastResult>;
        signArbitrary({ wallet, data }: {
            wallet: WalletConnection;
            data: Uint8Array;
        }): Promise<SigningResult>;
        verifyArbitrary({ wallet, data, signResult, }: {
            wallet: WalletConnection;
            data: Uint8Array;
            signResult: SigningResult;
        }): Promise<boolean>;
    };
};

declare const isMobile: () => boolean;
declare const isAndroid: () => boolean;
declare const isIOS: () => boolean;

declare function defaultBech32Config(mainPrefix?: string, validatorPrefix?: string, consensusPrefix?: string, publicPrefix?: string, operatorPrefix?: string): Bech32Config;
declare function objectToBase64(obj: object): string;
declare function nonNullable<T>(value: T): value is NonNullable<T>;

export { Account, Algo, Algos, AminoMsg, AminoSigningClient, ArbitrarySigningClient, BIP44, BasicAllowance, BasicAllowanceValue, Bech32Config, BitgetExtensionProvider, BitgetMobileProvider, BroadcastClient, BroadcastResult, CitadelOneExtensionProvider, Coin, CompassExtensionProvider, CosmiframeExtensionProvider, CosmosMsg, CosmostationExtensionProvider, CosmostationMobileProvider, CypherWalletExtensionProvider, DEFAULT_BIP44_COIN_TYPE, DEFAULT_CHAIN_PREFIX, DEFAULT_CURRENCY, DEFAULT_GAS_MULTIPLIER, DEFAULT_GAS_PRICE, EthSignType, FakeOfflineSigner, Fee, FinExtensionProvider, KeplrExtensionProvider, KeplrMobileProvider, LeapCosmosExtensionProvider, LeapCosmosMobileProvider, LeapMetamaskCosmosSnapExtensionProvider, MathExtensionProvider, MetamaskExtensionProvider, MetamaskMobileProvider, MobileConnectResponse, MsgAllianceDelegate, MsgAllianceDelegateValue, MsgBeginUnlocking, MsgBeginUnlockingValue, MsgCancelSpotOrder, MsgCancelSpotOrderValue, MsgCreateSpotLimitOrder, MsgCreateSpotLimitOrderValue, MsgDepositForBurn, MsgDepositForBurnValue, MsgExecuteContract, MsgExecuteContractValue, MsgGrantAllowance, MsgGrantAllowanceValue, MsgInstantiateContract, MsgInstantiateContractValue, MsgLockTokens, MsgLockTokensValue, MsgMigrateContract, MsgMigrateContractValue, MsgRevokeAllowance, MsgRevokeAllowanceValue, MsgSend, MsgSendValue, MsgTransfer, MsgTransferValue, Network, NetworkCurrency, NinjiExtensionProvider, OWalletCosmosExtensionProvider, OfflineDirectSigningClient, OkxWalletExtensionProvider, OnseiMobileProvider, ProtoMsg, SafePalExtensionProvider, SignAndBroadcastClient, SigningResult, SimulateClient, SimulateResult, StationExtensionProvider, StdFee, TransactionMsg, TrustWalletExtensionProvider, VectisCosmosExtensionProvider, WalletConnection, WalletExtensionProvider, WalletMobileProvider, WalletMobileSession, XDEFICosmosExtensionProvider, addCoins, coin, coins, createEmptySignDoc, defaultBech32Config, extendedRegistryTypes, fromInjectiveCosmosChainToEthereumChain, fromInjectiveEthereumChainToCosmosChain, imTokenExtensionProvider, isAndroid, isIOS, isInjectiveNetwork, isMobile, nonNullable, objectToBase64, parseCoins };