import { BinaryReader, BinaryWriter } from "../../../../binary";
import { JsonSafe } from "../../../../json-safe";
/** AccessType defines the types of permissions for the operations */
export declare enum AccessType {
    /** ACCESS_TYPE_PERMISSIONLESS - ACCESS_TYPE_PERMISSIONLESS does not restrict the operation to anyone */
    ACCESS_TYPE_PERMISSIONLESS = 0,
    /** ACCESS_TYPE_RESTRICTED - ACCESS_TYPE_RESTRICTED restrict the operation to anyone */
    ACCESS_TYPE_RESTRICTED = 1,
    /** ACCESS_TYPE_PERMISSIONED - ACCESS_TYPE_PERMISSIONED only allows the operation for specific addresses */
    ACCESS_TYPE_PERMISSIONED = 2,
    UNRECOGNIZED = -1
}
export declare const AccessTypeSDKType: typeof AccessType;
export declare const AccessTypeAmino: typeof AccessType;
export declare function accessTypeFromJSON(object: any): AccessType;
export declare function accessTypeToJSON(object: AccessType): string;
/** Params defines the EVM module parameters */
export interface Params {
    /**
     * evm_denom represents the token denomination used to run the EVM state
     * transitions.
     */
    evmDenom: string;
    /** extra_eips defines the additional EIPs for the vm.Config */
    extraEips: bigint[];
    /**
     * allow_unprotected_txs defines if replay-protected (i.e non EIP155
     * signed) transactions can be executed on the state machine.
     */
    allowUnprotectedTxs: boolean;
    /** evm_channels is the list of channel identifiers from EVM compatible chains */
    evmChannels: string[];
    /** access_control defines the permission policy of the EVM */
    accessControl: AccessControl;
    /**
     * active_static_precompiles defines the slice of hex addresses of the
     * precompiled contracts that are active
     */
    activeStaticPrecompiles: string[];
}
export interface ParamsProtoMsg {
    typeUrl: "/cosmos.evm.vm.v1.Params";
    value: Uint8Array;
}
/**
 * Params defines the EVM module parameters
 * @name ParamsAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Params
 */
export interface ParamsAmino {
    /**
     * evm_denom represents the token denomination used to run the EVM state
     * transitions.
     */
    evm_denom?: string;
    /**
     * extra_eips defines the additional EIPs for the vm.Config
     */
    extra_eips?: string[];
    /**
     * allow_unprotected_txs defines if replay-protected (i.e non EIP155
     * signed) transactions can be executed on the state machine.
     */
    allow_unprotected_txs?: boolean;
    /**
     * evm_channels is the list of channel identifiers from EVM compatible chains
     */
    evm_channels?: string[];
    /**
     * access_control defines the permission policy of the EVM
     */
    access_control?: AccessControlAmino;
    /**
     * active_static_precompiles defines the slice of hex addresses of the
     * precompiled contracts that are active
     */
    active_static_precompiles?: string[];
}
export interface ParamsAminoMsg {
    type: "cosmos/evm/v1/Params";
    value: ParamsAmino;
}
/** Params defines the EVM module parameters */
export interface ParamsSDKType {
    evm_denom: string;
    extra_eips: bigint[];
    allow_unprotected_txs: boolean;
    evm_channels: string[];
    access_control: AccessControlSDKType;
    active_static_precompiles: string[];
}
/**
 * AccessControl defines the permission policy of the EVM
 * for creating and calling contracts
 */
export interface AccessControl {
    /** create defines the permission policy for creating contracts */
    create: AccessControlType;
    /** call defines the permission policy for calling contracts */
    call: AccessControlType;
}
export interface AccessControlProtoMsg {
    typeUrl: "/cosmos.evm.vm.v1.AccessControl";
    value: Uint8Array;
}
/**
 * AccessControl defines the permission policy of the EVM
 * for creating and calling contracts
 * @name AccessControlAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessControl
 */
export interface AccessControlAmino {
    /**
     * create defines the permission policy for creating contracts
     */
    create?: AccessControlTypeAmino;
    /**
     * call defines the permission policy for calling contracts
     */
    call?: AccessControlTypeAmino;
}
export interface AccessControlAminoMsg {
    type: "cosmos-sdk/AccessControl";
    value: AccessControlAmino;
}
/**
 * AccessControl defines the permission policy of the EVM
 * for creating and calling contracts
 */
export interface AccessControlSDKType {
    create: AccessControlTypeSDKType;
    call: AccessControlTypeSDKType;
}
/** AccessControlType defines the permission type for policies */
export interface AccessControlType {
    /** access_type defines which type of permission is required for the operation */
    accessType: AccessType;
    /**
     * access_control_list defines defines different things depending on the
     * AccessType:
     * - ACCESS_TYPE_PERMISSIONLESS: list of addresses that are blocked from
     * performing the operation
     * - ACCESS_TYPE_RESTRICTED: ignored
     * - ACCESS_TYPE_PERMISSIONED: list of addresses that are allowed to perform
     * the operation
     */
    accessControlList: string[];
}
export interface AccessControlTypeProtoMsg {
    typeUrl: "/cosmos.evm.vm.v1.AccessControlType";
    value: Uint8Array;
}
/**
 * AccessControlType defines the permission type for policies
 * @name AccessControlTypeAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessControlType
 */
export interface AccessControlTypeAmino {
    /**
     * access_type defines which type of permission is required for the operation
     */
    access_type?: AccessType;
    /**
     * access_control_list defines defines different things depending on the
     * AccessType:
     * - ACCESS_TYPE_PERMISSIONLESS: list of addresses that are blocked from
     * performing the operation
     * - ACCESS_TYPE_RESTRICTED: ignored
     * - ACCESS_TYPE_PERMISSIONED: list of addresses that are allowed to perform
     * the operation
     */
    access_control_list?: string[];
}
export interface AccessControlTypeAminoMsg {
    type: "cosmos-sdk/AccessControlType";
    value: AccessControlTypeAmino;
}
/** AccessControlType defines the permission type for policies */
export interface AccessControlTypeSDKType {
    access_type: AccessType;
    access_control_list: string[];
}
/**
 * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 * instead of *big.Int.
 */
export interface ChainConfig {
    /** homestead_block switch (nil no fork, 0 = already homestead) */
    homesteadBlock: string;
    /** dao_fork_block corresponds to TheDAO hard-fork switch block (nil no fork) */
    daoForkBlock: string;
    /**
     * dao_fork_support defines whether the nodes supports or opposes the DAO
     * hard-fork
     */
    daoForkSupport: boolean;
    /**
     * eip150_block: EIP150 implements the Gas price changes
     * (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork)
     */
    eip150Block: string;
    /** eip155_block: EIP155Block HF block */
    eip155Block: string;
    /** eip158_block: EIP158 HF block */
    eip158Block: string;
    /**
     * byzantium_block: Byzantium switch block (nil no fork, 0 = already on
     * byzantium)
     */
    byzantiumBlock: string;
    /**
     * constantinople_block: Constantinople switch block (nil no fork, 0 = already
     * activated)
     */
    constantinopleBlock: string;
    /** petersburg_block: Petersburg switch block (nil same as Constantinople) */
    petersburgBlock: string;
    /**
     * istanbul_block: Istanbul switch block (nil no fork, 0 = already on
     * istanbul)
     */
    istanbulBlock: string;
    /**
     * muir_glacier_block: Eip-2384 (bomb delay) switch block (nil no fork, 0 =
     * already activated)
     */
    muirGlacierBlock: string;
    /** berlin_block: Berlin switch block (nil = no fork, 0 = already on berlin) */
    berlinBlock: string;
    /** london_block: London switch block (nil = no fork, 0 = already on london) */
    londonBlock: string;
    /**
     * arrow_glacier_block: Eip-4345 (bomb delay) switch block (nil = no fork, 0 =
     * already activated)
     */
    arrowGlacierBlock: string;
    /**
     * gray_glacier_block: EIP-5133 (bomb delay) switch block (nil = no fork, 0 =
     * already activated)
     */
    grayGlacierBlock: string;
    /**
     * merge_netsplit_block: Virtual fork after The Merge to use as a network
     * splitter
     */
    mergeNetsplitBlock: string;
    /** chain_id is the id of the chain (EIP-155) */
    chainId: bigint;
    /** denom is the denomination used on the EVM */
    denom: string;
    /** decimals is the real decimal precision of the denomination used on the EVM */
    decimals: bigint;
    /**
     * shanghai_time: Shanghai switch time (nil = no fork, 0 = already on
     * shanghai)
     */
    shanghaiTime: string;
    /** cancun_time: Cancun switch time (nil = no fork, 0 = already on cancun) */
    cancunTime: string;
    /** prague_time: Prague switch time (nil = no fork, 0 = already on prague) */
    pragueTime: string;
    /** verkle_time: Verkle switch time (nil = no fork, 0 = already on verkle) */
    verkleTime: string;
    /** osaka_time: Osaka switch time (nil = no fork, 0 = already on osaka) */
    osakaTime: string;
}
export interface ChainConfigProtoMsg {
    typeUrl: "/cosmos.evm.vm.v1.ChainConfig";
    value: Uint8Array;
}
/**
 * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 * instead of *big.Int.
 * @name ChainConfigAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.ChainConfig
 */
export interface ChainConfigAmino {
    /**
     * homestead_block switch (nil no fork, 0 = already homestead)
     */
    homestead_block?: string;
    /**
     * dao_fork_block corresponds to TheDAO hard-fork switch block (nil no fork)
     */
    dao_fork_block?: string;
    /**
     * dao_fork_support defines whether the nodes supports or opposes the DAO
     * hard-fork
     */
    dao_fork_support?: boolean;
    /**
     * eip150_block: EIP150 implements the Gas price changes
     * (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork)
     */
    eip150_block?: string;
    /**
     * eip155_block: EIP155Block HF block
     */
    eip155_block?: string;
    /**
     * eip158_block: EIP158 HF block
     */
    eip158_block?: string;
    /**
     * byzantium_block: Byzantium switch block (nil no fork, 0 = already on
     * byzantium)
     */
    byzantium_block?: string;
    /**
     * constantinople_block: Constantinople switch block (nil no fork, 0 = already
     * activated)
     */
    constantinople_block?: string;
    /**
     * petersburg_block: Petersburg switch block (nil same as Constantinople)
     */
    petersburg_block?: string;
    /**
     * istanbul_block: Istanbul switch block (nil no fork, 0 = already on
     * istanbul)
     */
    istanbul_block?: string;
    /**
     * muir_glacier_block: Eip-2384 (bomb delay) switch block (nil no fork, 0 =
     * already activated)
     */
    muir_glacier_block?: string;
    /**
     * berlin_block: Berlin switch block (nil = no fork, 0 = already on berlin)
     */
    berlin_block?: string;
    /**
     * london_block: London switch block (nil = no fork, 0 = already on london)
     */
    london_block?: string;
    /**
     * arrow_glacier_block: Eip-4345 (bomb delay) switch block (nil = no fork, 0 =
     * already activated)
     */
    arrow_glacier_block?: string;
    /**
     * gray_glacier_block: EIP-5133 (bomb delay) switch block (nil = no fork, 0 =
     * already activated)
     */
    gray_glacier_block?: string;
    /**
     * merge_netsplit_block: Virtual fork after The Merge to use as a network
     * splitter
     */
    merge_netsplit_block?: string;
    /**
     * chain_id is the id of the chain (EIP-155)
     */
    chain_id?: string;
    /**
     * denom is the denomination used on the EVM
     */
    denom?: string;
    /**
     * decimals is the real decimal precision of the denomination used on the EVM
     */
    decimals?: string;
    /**
     * shanghai_time: Shanghai switch time (nil = no fork, 0 = already on
     * shanghai)
     */
    shanghai_time?: string;
    /**
     * cancun_time: Cancun switch time (nil = no fork, 0 = already on cancun)
     */
    cancun_time?: string;
    /**
     * prague_time: Prague switch time (nil = no fork, 0 = already on prague)
     */
    prague_time?: string;
    /**
     * verkle_time: Verkle switch time (nil = no fork, 0 = already on verkle)
     */
    verkle_time?: string;
    /**
     * osaka_time: Osaka switch time (nil = no fork, 0 = already on osaka)
     */
    osaka_time?: string;
}
export interface ChainConfigAminoMsg {
    type: "cosmos-sdk/ChainConfig";
    value: ChainConfigAmino;
}
/**
 * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 * instead of *big.Int.
 */
export interface ChainConfigSDKType {
    homestead_block: string;
    dao_fork_block: string;
    dao_fork_support: boolean;
    eip150_block: string;
    eip155_block: string;
    eip158_block: string;
    byzantium_block: string;
    constantinople_block: string;
    petersburg_block: string;
    istanbul_block: string;
    muir_glacier_block: string;
    berlin_block: string;
    london_block: string;
    arrow_glacier_block: string;
    gray_glacier_block: string;
    merge_netsplit_block: string;
    chain_id: bigint;
    denom: string;
    decimals: bigint;
    shanghai_time: string;
    cancun_time: string;
    prague_time: string;
    verkle_time: string;
    osaka_time: string;
}
/** State represents a single Storage key value pair item. */
export interface State {
    /** key is the stored key */
    key: string;
    /** value is the stored value for the given key */
    value: string;
}
export interface StateProtoMsg {
    typeUrl: "/cosmos.evm.vm.v1.State";
    value: Uint8Array;
}
/**
 * State represents a single Storage key value pair item.
 * @name StateAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.State
 */
export interface StateAmino {
    /**
     * key is the stored key
     */
    key?: string;
    /**
     * value is the stored value for the given key
     */
    value?: string;
}
export interface StateAminoMsg {
    type: "cosmos-sdk/State";
    value: StateAmino;
}
/** State represents a single Storage key value pair item. */
export interface StateSDKType {
    key: string;
    value: string;
}
/**
 * TransactionLogs define the logs generated from a transaction execution
 * with a given hash. It it used for import/export data as transactions are not
 * persisted on blockchain state after an upgrade.
 */
export interface TransactionLogs {
    /** hash of the transaction */
    hash: string;
    /** logs is an array of Logs for the given transaction hash */
    logs: Log[];
}
export interface TransactionLogsProtoMsg {
    typeUrl: "/cosmos.evm.vm.v1.TransactionLogs";
    value: Uint8Array;
}
/**
 * TransactionLogs define the logs generated from a transaction execution
 * with a given hash. It it used for import/export data as transactions are not
 * persisted on blockchain state after an upgrade.
 * @name TransactionLogsAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TransactionLogs
 */
export interface TransactionLogsAmino {
    /**
     * hash of the transaction
     */
    hash?: string;
    /**
     * logs is an array of Logs for the given transaction hash
     */
    logs?: LogAmino[];
}
export interface TransactionLogsAminoMsg {
    type: "cosmos-sdk/TransactionLogs";
    value: TransactionLogsAmino;
}
/**
 * TransactionLogs define the logs generated from a transaction execution
 * with a given hash. It it used for import/export data as transactions are not
 * persisted on blockchain state after an upgrade.
 */
export interface TransactionLogsSDKType {
    hash: string;
    logs: LogSDKType[];
}
/**
 * Log represents an protobuf compatible Ethereum Log that defines a contract
 * log event. These events are generated by the LOG opcode and stored/indexed by
 * the node.
 *
 * NOTE: address, topics and data are consensus fields. The rest of the fields
 * are derived, i.e. filled in by the nodes, but not secured by consensus.
 */
export interface Log {
    /** address of the contract that generated the event */
    address: string;
    /** topics is a list of topics provided by the contract. */
    topics: string[];
    /** data which is supplied by the contract, usually ABI-encoded */
    data: Uint8Array;
    /** block_number of the block in which the transaction was included */
    blockNumber: bigint;
    /** tx_hash is the transaction hash */
    txHash: string;
    /** tx_index of the transaction in the block */
    txIndex: bigint;
    /** block_hash of the block in which the transaction was included */
    blockHash: string;
    /** index of the log in the block */
    index: bigint;
    /**
     * removed is true if this log was reverted due to a chain
     * reorganisation. You must pay attention to this field if you receive logs
     * through a filter query.
     */
    removed: boolean;
}
export interface LogProtoMsg {
    typeUrl: "/cosmos.evm.vm.v1.Log";
    value: Uint8Array;
}
/**
 * Log represents an protobuf compatible Ethereum Log that defines a contract
 * log event. These events are generated by the LOG opcode and stored/indexed by
 * the node.
 *
 * NOTE: address, topics and data are consensus fields. The rest of the fields
 * are derived, i.e. filled in by the nodes, but not secured by consensus.
 * @name LogAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Log
 */
export interface LogAmino {
    /**
     * address of the contract that generated the event
     */
    address?: string;
    /**
     * topics is a list of topics provided by the contract.
     */
    topics?: string[];
    /**
     * data which is supplied by the contract, usually ABI-encoded
     */
    data?: string;
    /**
     * block_number of the block in which the transaction was included
     */
    block_number: string;
    /**
     * tx_hash is the transaction hash
     */
    tx_hash: string;
    /**
     * tx_index of the transaction in the block
     */
    tx_index: string;
    /**
     * block_hash of the block in which the transaction was included
     */
    block_hash: string;
    /**
     * index of the log in the block
     */
    index: string;
    /**
     * removed is true if this log was reverted due to a chain
     * reorganisation. You must pay attention to this field if you receive logs
     * through a filter query.
     */
    removed?: boolean;
}
export interface LogAminoMsg {
    type: "cosmos-sdk/Log";
    value: LogAmino;
}
/**
 * Log represents an protobuf compatible Ethereum Log that defines a contract
 * log event. These events are generated by the LOG opcode and stored/indexed by
 * the node.
 *
 * NOTE: address, topics and data are consensus fields. The rest of the fields
 * are derived, i.e. filled in by the nodes, but not secured by consensus.
 */
export interface LogSDKType {
    address: string;
    topics: string[];
    data: Uint8Array;
    block_number: bigint;
    tx_hash: string;
    tx_index: bigint;
    block_hash: string;
    index: bigint;
    removed: boolean;
}
/** TxResult stores results of Tx execution. */
export interface TxResult {
    /**
     * contract_address contains the ethereum address of the created contract (if
     * any). If the state transition is an evm.Call, the contract address will be
     * empty.
     */
    contractAddress: string;
    /** bloom represents the bloom filter bytes */
    bloom: Uint8Array;
    /**
     * tx_logs contains the transaction hash and the proto-compatible ethereum
     * logs.
     */
    txLogs: TransactionLogs;
    /** ret defines the bytes from the execution. */
    ret: Uint8Array;
    /** reverted flag is set to true when the call has been reverted */
    reverted: boolean;
    /** gas_used notes the amount of gas consumed while execution */
    gasUsed: bigint;
}
export interface TxResultProtoMsg {
    typeUrl: "/cosmos.evm.vm.v1.TxResult";
    value: Uint8Array;
}
/**
 * TxResult stores results of Tx execution.
 * @name TxResultAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TxResult
 */
export interface TxResultAmino {
    /**
     * contract_address contains the ethereum address of the created contract (if
     * any). If the state transition is an evm.Call, the contract address will be
     * empty.
     */
    contract_address?: string;
    /**
     * bloom represents the bloom filter bytes
     */
    bloom?: string;
    /**
     * tx_logs contains the transaction hash and the proto-compatible ethereum
     * logs.
     */
    tx_logs: TransactionLogsAmino;
    /**
     * ret defines the bytes from the execution.
     */
    ret?: string;
    /**
     * reverted flag is set to true when the call has been reverted
     */
    reverted?: boolean;
    /**
     * gas_used notes the amount of gas consumed while execution
     */
    gas_used?: string;
}
export interface TxResultAminoMsg {
    type: "cosmos-sdk/TxResult";
    value: TxResultAmino;
}
/** TxResult stores results of Tx execution. */
export interface TxResultSDKType {
    contract_address: string;
    bloom: Uint8Array;
    tx_logs: TransactionLogsSDKType;
    ret: Uint8Array;
    reverted: boolean;
    gas_used: bigint;
}
/** AccessTuple is the element type of an access list. */
export interface AccessTuple {
    /** address is a hex formatted ethereum address */
    address: string;
    /** storage_keys are hex formatted hashes of the storage keys */
    storageKeys: string[];
}
export interface AccessTupleProtoMsg {
    typeUrl: "/cosmos.evm.vm.v1.AccessTuple";
    value: Uint8Array;
}
/**
 * AccessTuple is the element type of an access list.
 * @name AccessTupleAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessTuple
 */
export interface AccessTupleAmino {
    /**
     * address is a hex formatted ethereum address
     */
    address?: string;
    /**
     * storage_keys are hex formatted hashes of the storage keys
     */
    storage_keys: string[];
}
export interface AccessTupleAminoMsg {
    type: "cosmos-sdk/AccessTuple";
    value: AccessTupleAmino;
}
/** AccessTuple is the element type of an access list. */
export interface AccessTupleSDKType {
    address: string;
    storage_keys: string[];
}
/** TraceConfig holds extra parameters to trace functions. */
export interface TraceConfig {
    /** tracer is a custom javascript tracer */
    tracer: string;
    /**
     * timeout overrides the default timeout of 5 seconds for JavaScript-based
     * tracing calls
     */
    timeout: string;
    /** reexec defines the number of blocks the tracer is willing to go back */
    reexec: bigint;
    /** disable_stack switches stack capture */
    disableStack: boolean;
    /** disable_storage switches storage capture */
    disableStorage: boolean;
    /** debug can be used to print output during capture end */
    debug: boolean;
    /** limit defines the maximum length of output, but zero means unlimited */
    limit: number;
    /** overrides can be used to execute a trace using future fork rules */
    overrides?: ChainConfig;
    /** enable_memory switches memory capture */
    enableMemory: boolean;
    /** enable_return_data switches the capture of return data */
    enableReturnData: boolean;
    /** tracer_json_config configures the tracer using a JSON string */
    tracerJsonConfig: string;
}
export interface TraceConfigProtoMsg {
    typeUrl: "/cosmos.evm.vm.v1.TraceConfig";
    value: Uint8Array;
}
/**
 * TraceConfig holds extra parameters to trace functions.
 * @name TraceConfigAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TraceConfig
 */
export interface TraceConfigAmino {
    /**
     * tracer is a custom javascript tracer
     */
    tracer?: string;
    /**
     * timeout overrides the default timeout of 5 seconds for JavaScript-based
     * tracing calls
     */
    timeout?: string;
    /**
     * reexec defines the number of blocks the tracer is willing to go back
     */
    reexec?: string;
    /**
     * disable_stack switches stack capture
     */
    disable_stack: boolean;
    /**
     * disable_storage switches storage capture
     */
    disable_storage: boolean;
    /**
     * debug can be used to print output during capture end
     */
    debug?: boolean;
    /**
     * limit defines the maximum length of output, but zero means unlimited
     */
    limit?: number;
    /**
     * overrides can be used to execute a trace using future fork rules
     */
    overrides?: ChainConfigAmino;
    /**
     * enable_memory switches memory capture
     */
    enable_memory: boolean;
    /**
     * enable_return_data switches the capture of return data
     */
    enable_return_data: boolean;
    /**
     * tracer_json_config configures the tracer using a JSON string
     */
    tracer_json_config: string;
}
export interface TraceConfigAminoMsg {
    type: "cosmos-sdk/TraceConfig";
    value: TraceConfigAmino;
}
/** TraceConfig holds extra parameters to trace functions. */
export interface TraceConfigSDKType {
    tracer: string;
    timeout: string;
    reexec: bigint;
    disable_stack: boolean;
    disable_storage: boolean;
    debug: boolean;
    limit: number;
    overrides?: ChainConfigSDKType;
    enable_memory: boolean;
    enable_return_data: boolean;
    tracer_json_config: string;
}
export declare const Params: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is Params;
    isSDK(o: any): o is ParamsSDKType;
    isAmino(o: any): o is ParamsAmino;
    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Params;
    fromJSON(object: any): Params;
    toJSON(message: Params): JsonSafe<Params>;
    fromPartial(object: Partial<Params>): Params;
    fromAmino(object: ParamsAmino): Params;
    toAmino(message: Params): ParamsAmino;
    fromAminoMsg(object: ParamsAminoMsg): Params;
    toAminoMsg(message: Params): ParamsAminoMsg;
    fromProtoMsg(message: ParamsProtoMsg): Params;
    toProto(message: Params): Uint8Array;
    toProtoMsg(message: Params): ParamsProtoMsg;
};
export declare const AccessControl: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is AccessControl;
    isSDK(o: any): o is AccessControlSDKType;
    isAmino(o: any): o is AccessControlAmino;
    encode(message: AccessControl, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): AccessControl;
    fromJSON(object: any): AccessControl;
    toJSON(message: AccessControl): JsonSafe<AccessControl>;
    fromPartial(object: Partial<AccessControl>): AccessControl;
    fromAmino(object: AccessControlAmino): AccessControl;
    toAmino(message: AccessControl): AccessControlAmino;
    fromAminoMsg(object: AccessControlAminoMsg): AccessControl;
    toAminoMsg(message: AccessControl): AccessControlAminoMsg;
    fromProtoMsg(message: AccessControlProtoMsg): AccessControl;
    toProto(message: AccessControl): Uint8Array;
    toProtoMsg(message: AccessControl): AccessControlProtoMsg;
};
export declare const AccessControlType: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is AccessControlType;
    isSDK(o: any): o is AccessControlTypeSDKType;
    isAmino(o: any): o is AccessControlTypeAmino;
    encode(message: AccessControlType, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): AccessControlType;
    fromJSON(object: any): AccessControlType;
    toJSON(message: AccessControlType): JsonSafe<AccessControlType>;
    fromPartial(object: Partial<AccessControlType>): AccessControlType;
    fromAmino(object: AccessControlTypeAmino): AccessControlType;
    toAmino(message: AccessControlType): AccessControlTypeAmino;
    fromAminoMsg(object: AccessControlTypeAminoMsg): AccessControlType;
    toAminoMsg(message: AccessControlType): AccessControlTypeAminoMsg;
    fromProtoMsg(message: AccessControlTypeProtoMsg): AccessControlType;
    toProto(message: AccessControlType): Uint8Array;
    toProtoMsg(message: AccessControlType): AccessControlTypeProtoMsg;
};
export declare const ChainConfig: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is ChainConfig;
    isSDK(o: any): o is ChainConfigSDKType;
    isAmino(o: any): o is ChainConfigAmino;
    encode(message: ChainConfig, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ChainConfig;
    fromJSON(object: any): ChainConfig;
    toJSON(message: ChainConfig): JsonSafe<ChainConfig>;
    fromPartial(object: Partial<ChainConfig>): ChainConfig;
    fromAmino(object: ChainConfigAmino): ChainConfig;
    toAmino(message: ChainConfig): ChainConfigAmino;
    fromAminoMsg(object: ChainConfigAminoMsg): ChainConfig;
    toAminoMsg(message: ChainConfig): ChainConfigAminoMsg;
    fromProtoMsg(message: ChainConfigProtoMsg): ChainConfig;
    toProto(message: ChainConfig): Uint8Array;
    toProtoMsg(message: ChainConfig): ChainConfigProtoMsg;
};
export declare const State: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is State;
    isSDK(o: any): o is StateSDKType;
    isAmino(o: any): o is StateAmino;
    encode(message: State, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): State;
    fromJSON(object: any): State;
    toJSON(message: State): JsonSafe<State>;
    fromPartial(object: Partial<State>): State;
    fromAmino(object: StateAmino): State;
    toAmino(message: State): StateAmino;
    fromAminoMsg(object: StateAminoMsg): State;
    toAminoMsg(message: State): StateAminoMsg;
    fromProtoMsg(message: StateProtoMsg): State;
    toProto(message: State): Uint8Array;
    toProtoMsg(message: State): StateProtoMsg;
};
export declare const TransactionLogs: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is TransactionLogs;
    isSDK(o: any): o is TransactionLogsSDKType;
    isAmino(o: any): o is TransactionLogsAmino;
    encode(message: TransactionLogs, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): TransactionLogs;
    fromJSON(object: any): TransactionLogs;
    toJSON(message: TransactionLogs): JsonSafe<TransactionLogs>;
    fromPartial(object: Partial<TransactionLogs>): TransactionLogs;
    fromAmino(object: TransactionLogsAmino): TransactionLogs;
    toAmino(message: TransactionLogs): TransactionLogsAmino;
    fromAminoMsg(object: TransactionLogsAminoMsg): TransactionLogs;
    toAminoMsg(message: TransactionLogs): TransactionLogsAminoMsg;
    fromProtoMsg(message: TransactionLogsProtoMsg): TransactionLogs;
    toProto(message: TransactionLogs): Uint8Array;
    toProtoMsg(message: TransactionLogs): TransactionLogsProtoMsg;
};
export declare const Log: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is Log;
    isSDK(o: any): o is LogSDKType;
    isAmino(o: any): o is LogAmino;
    encode(message: Log, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Log;
    fromJSON(object: any): Log;
    toJSON(message: Log): JsonSafe<Log>;
    fromPartial(object: Partial<Log>): Log;
    fromAmino(object: LogAmino): Log;
    toAmino(message: Log): LogAmino;
    fromAminoMsg(object: LogAminoMsg): Log;
    toAminoMsg(message: Log): LogAminoMsg;
    fromProtoMsg(message: LogProtoMsg): Log;
    toProto(message: Log): Uint8Array;
    toProtoMsg(message: Log): LogProtoMsg;
};
export declare const TxResult: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is TxResult;
    isSDK(o: any): o is TxResultSDKType;
    isAmino(o: any): o is TxResultAmino;
    encode(message: TxResult, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): TxResult;
    fromJSON(object: any): TxResult;
    toJSON(message: TxResult): JsonSafe<TxResult>;
    fromPartial(object: Partial<TxResult>): TxResult;
    fromAmino(object: TxResultAmino): TxResult;
    toAmino(message: TxResult): TxResultAmino;
    fromAminoMsg(object: TxResultAminoMsg): TxResult;
    toAminoMsg(message: TxResult): TxResultAminoMsg;
    fromProtoMsg(message: TxResultProtoMsg): TxResult;
    toProto(message: TxResult): Uint8Array;
    toProtoMsg(message: TxResult): TxResultProtoMsg;
};
export declare const AccessTuple: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is AccessTuple;
    isSDK(o: any): o is AccessTupleSDKType;
    isAmino(o: any): o is AccessTupleAmino;
    encode(message: AccessTuple, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): AccessTuple;
    fromJSON(object: any): AccessTuple;
    toJSON(message: AccessTuple): JsonSafe<AccessTuple>;
    fromPartial(object: Partial<AccessTuple>): AccessTuple;
    fromAmino(object: AccessTupleAmino): AccessTuple;
    toAmino(message: AccessTuple): AccessTupleAmino;
    fromAminoMsg(object: AccessTupleAminoMsg): AccessTuple;
    toAminoMsg(message: AccessTuple): AccessTupleAminoMsg;
    fromProtoMsg(message: AccessTupleProtoMsg): AccessTuple;
    toProto(message: AccessTuple): Uint8Array;
    toProtoMsg(message: AccessTuple): AccessTupleProtoMsg;
};
export declare const TraceConfig: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is TraceConfig;
    isSDK(o: any): o is TraceConfigSDKType;
    isAmino(o: any): o is TraceConfigAmino;
    encode(message: TraceConfig, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): TraceConfig;
    fromJSON(object: any): TraceConfig;
    toJSON(message: TraceConfig): JsonSafe<TraceConfig>;
    fromPartial(object: Partial<TraceConfig>): TraceConfig;
    fromAmino(object: TraceConfigAmino): TraceConfig;
    toAmino(message: TraceConfig): TraceConfigAmino;
    fromAminoMsg(object: TraceConfigAminoMsg): TraceConfig;
    toAminoMsg(message: TraceConfig): TraceConfigAminoMsg;
    fromProtoMsg(message: TraceConfigProtoMsg): TraceConfig;
    toProto(message: TraceConfig): Uint8Array;
    toProtoMsg(message: TraceConfig): TraceConfigProtoMsg;
};