import { BinaryReader, BinaryWriter } from "../../../binary.js";
import { DeepPartial } from "../../../helpers.js";

//#region src/ethermint/evm/v1/evm.d.ts
/**
 * Params defines the EVM module parameters
 * @name Params
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.Params
 */
interface Params {
  /**
   * evm_denom represents the token denomination used to run the EVM state
   * transitions.
   */
  evmDenom: string;
  /**
   * enable_create toggles state transitions that use the vm.Create function
   */
  enableCreate: boolean;
  /**
   * enable_call toggles state transitions that use the vm.Call function
   */
  enableCall: boolean;
  /**
   * extra_eips defines the additional EIPs for the vm.Config
   */
  extraEips: bigint[];
  /**
   * chain_config defines the EVM chain configuration parameters
   */
  chainConfig: ChainConfig;
  /**
   * allow_unprotected_txs defines if replay-protected (i.e non EIP155
   * signed) transactions can be executed on the state machine.
   */
  allowUnprotectedTxs: boolean;
}
interface ParamsProtoMsg {
  typeUrl: "/ethermint.evm.v1.Params";
  value: Uint8Array;
}
/**
 * Params defines the EVM module parameters
 * @name ParamsAmino
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.Params
 */
interface ParamsAmino {
  /**
   * evm_denom represents the token denomination used to run the EVM state
   * transitions.
   */
  evm_denom: string;
  /**
   * enable_create toggles state transitions that use the vm.Create function
   */
  enable_create: boolean;
  /**
   * enable_call toggles state transitions that use the vm.Call function
   */
  enable_call: boolean;
  /**
   * extra_eips defines the additional EIPs for the vm.Config
   */
  extra_eips: string[];
  /**
   * chain_config defines the EVM chain configuration parameters
   */
  chain_config: ChainConfigAmino;
  /**
   * allow_unprotected_txs defines if replay-protected (i.e non EIP155
   * signed) transactions can be executed on the state machine.
   */
  allow_unprotected_txs: boolean;
}
interface ParamsAminoMsg {
  type: "ethermint/x/evm/Params";
  value: ParamsAmino;
}
/**
 * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 * instead of *big.Int.
 * @name ChainConfig
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.ChainConfig
 */
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;
  /**
   * eip150_hash: EIP150 HF hash (needed for header only clients as only gas pricing changed)
   */
  eip150Hash: 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;
  /**
   * shanghai_block switch block (nil = no fork, 0 = already on shanghai)
   */
  shanghaiBlock: string;
  /**
   * cancun_block switch block (nil = no fork, 0 = already on cancun)
   */
  cancunBlock: string;
}
interface ChainConfigProtoMsg {
  typeUrl: "/ethermint.evm.v1.ChainConfig";
  value: Uint8Array;
}
/**
 * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 * instead of *big.Int.
 * @name ChainConfigAmino
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.ChainConfig
 */
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;
  /**
   * eip150_hash: EIP150 HF hash (needed for header only clients as only gas pricing changed)
   */
  eip150_hash: 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;
  /**
   * shanghai_block switch block (nil = no fork, 0 = already on shanghai)
   */
  shanghai_block: string;
  /**
   * cancun_block switch block (nil = no fork, 0 = already on cancun)
   */
  cancun_block: string;
}
interface ChainConfigAminoMsg {
  type: "/ethermint.evm.v1.ChainConfig";
  value: ChainConfigAmino;
}
/**
 * State represents a single Storage key value pair item.
 * @name State
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.State
 */
interface State {
  /**
   * key is the stored key
   */
  key: string;
  /**
   * value is the stored value for the given key
   */
  value: string;
}
interface StateProtoMsg {
  typeUrl: "/ethermint.evm.v1.State";
  value: Uint8Array;
}
/**
 * State represents a single Storage key value pair item.
 * @name StateAmino
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.State
 */
interface StateAmino {
  /**
   * key is the stored key
   */
  key: string;
  /**
   * value is the stored value for the given key
   */
  value: string;
}
interface StateAminoMsg {
  type: "/ethermint.evm.v1.State";
  value: StateAmino;
}
/**
 * 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 TransactionLogs
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.TransactionLogs
 */
interface TransactionLogs {
  /**
   * hash of the transaction
   */
  hash: string;
  /**
   * logs is an array of Logs for the given transaction hash
   */
  logs: Log[];
}
interface TransactionLogsProtoMsg {
  typeUrl: "/ethermint.evm.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 ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.TransactionLogs
 */
interface TransactionLogsAmino {
  /**
   * hash of the transaction
   */
  hash: string;
  /**
   * logs is an array of Logs for the given transaction hash
   */
  logs: LogAmino[];
}
interface TransactionLogsAminoMsg {
  type: "/ethermint.evm.v1.TransactionLogs";
  value: TransactionLogsAmino;
}
/**
 * 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 Log
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.Log
 */
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;
}
interface LogProtoMsg {
  typeUrl: "/ethermint.evm.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 ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.Log
 */
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;
}
interface LogAminoMsg {
  type: "/ethermint.evm.v1.Log";
  value: LogAmino;
}
/**
 * TxResult stores results of Tx execution.
 * @name TxResult
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.TxResult
 */
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;
}
interface TxResultProtoMsg {
  typeUrl: "/ethermint.evm.v1.TxResult";
  value: Uint8Array;
}
/**
 * TxResult stores results of Tx execution.
 * @name TxResultAmino
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.TxResult
 */
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;
}
interface TxResultAminoMsg {
  type: "/ethermint.evm.v1.TxResult";
  value: TxResultAmino;
}
/**
 * AccessTuple is the element type of an access list.
 * @name AccessTuple
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.AccessTuple
 */
interface AccessTuple {
  /**
   * address is a hex formatted ethereum address
   */
  address: string;
  /**
   * storage_keys are hex formatted hashes of the storage keys
   */
  storageKeys: string[];
}
interface AccessTupleProtoMsg {
  typeUrl: "/ethermint.evm.v1.AccessTuple";
  value: Uint8Array;
}
/**
 * AccessTuple is the element type of an access list.
 * @name AccessTupleAmino
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.AccessTuple
 */
interface AccessTupleAmino {
  /**
   * address is a hex formatted ethereum address
   */
  address: string;
  /**
   * storage_keys are hex formatted hashes of the storage keys
   */
  storage_keys: string[];
}
interface AccessTupleAminoMsg {
  type: "/ethermint.evm.v1.AccessTuple";
  value: AccessTupleAmino;
}
/**
 * TraceConfig holds extra parameters to trace functions.
 * @name TraceConfig
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.TraceConfig
 */
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;
}
interface TraceConfigProtoMsg {
  typeUrl: "/ethermint.evm.v1.TraceConfig";
  value: Uint8Array;
}
/**
 * TraceConfig holds extra parameters to trace functions.
 * @name TraceConfigAmino
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.TraceConfig
 */
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;
}
interface TraceConfigAminoMsg {
  type: "/ethermint.evm.v1.TraceConfig";
  value: TraceConfigAmino;
}
/**
 * Params defines the EVM module parameters
 * @name Params
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.Params
 */
declare const Params: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is Params;
  isAmino(o: any): o is ParamsAmino;
  encode(message: Params, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): Params;
  fromPartial(object: DeepPartial<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;
  registerTypeUrl(): void;
};
/**
 * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 * instead of *big.Int.
 * @name ChainConfig
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.ChainConfig
 */
declare const ChainConfig: {
  typeUrl: string;
  is(o: any): o is ChainConfig;
  isAmino(o: any): o is ChainConfigAmino;
  encode(message: ChainConfig, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): ChainConfig;
  fromPartial(object: DeepPartial<ChainConfig>): ChainConfig;
  fromAmino(object: ChainConfigAmino): ChainConfig;
  toAmino(message: ChainConfig): ChainConfigAmino;
  fromAminoMsg(object: ChainConfigAminoMsg): ChainConfig;
  fromProtoMsg(message: ChainConfigProtoMsg): ChainConfig;
  toProto(message: ChainConfig): Uint8Array;
  toProtoMsg(message: ChainConfig): ChainConfigProtoMsg;
  registerTypeUrl(): void;
};
/**
 * State represents a single Storage key value pair item.
 * @name State
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.State
 */
declare const State: {
  typeUrl: string;
  is(o: any): o is State;
  isAmino(o: any): o is StateAmino;
  encode(message: State, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): State;
  fromPartial(object: DeepPartial<State>): State;
  fromAmino(object: StateAmino): State;
  toAmino(message: State): StateAmino;
  fromAminoMsg(object: StateAminoMsg): State;
  fromProtoMsg(message: StateProtoMsg): State;
  toProto(message: State): Uint8Array;
  toProtoMsg(message: State): StateProtoMsg;
  registerTypeUrl(): void;
};
/**
 * 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 TransactionLogs
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.TransactionLogs
 */
declare const TransactionLogs: {
  typeUrl: string;
  is(o: any): o is TransactionLogs;
  isAmino(o: any): o is TransactionLogsAmino;
  encode(message: TransactionLogs, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): TransactionLogs;
  fromPartial(object: DeepPartial<TransactionLogs>): TransactionLogs;
  fromAmino(object: TransactionLogsAmino): TransactionLogs;
  toAmino(message: TransactionLogs): TransactionLogsAmino;
  fromAminoMsg(object: TransactionLogsAminoMsg): TransactionLogs;
  fromProtoMsg(message: TransactionLogsProtoMsg): TransactionLogs;
  toProto(message: TransactionLogs): Uint8Array;
  toProtoMsg(message: TransactionLogs): TransactionLogsProtoMsg;
  registerTypeUrl(): void;
};
/**
 * 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 Log
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.Log
 */
declare const Log: {
  typeUrl: string;
  is(o: any): o is Log;
  isAmino(o: any): o is LogAmino;
  encode(message: Log, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): Log;
  fromPartial(object: DeepPartial<Log>): Log;
  fromAmino(object: LogAmino): Log;
  toAmino(message: Log): LogAmino;
  fromAminoMsg(object: LogAminoMsg): Log;
  fromProtoMsg(message: LogProtoMsg): Log;
  toProto(message: Log): Uint8Array;
  toProtoMsg(message: Log): LogProtoMsg;
  registerTypeUrl(): void;
};
/**
 * TxResult stores results of Tx execution.
 * @name TxResult
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.TxResult
 */
declare const TxResult: {
  typeUrl: string;
  is(o: any): o is TxResult;
  isAmino(o: any): o is TxResultAmino;
  encode(message: TxResult, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): TxResult;
  fromPartial(object: DeepPartial<TxResult>): TxResult;
  fromAmino(object: TxResultAmino): TxResult;
  toAmino(message: TxResult): TxResultAmino;
  fromAminoMsg(object: TxResultAminoMsg): TxResult;
  fromProtoMsg(message: TxResultProtoMsg): TxResult;
  toProto(message: TxResult): Uint8Array;
  toProtoMsg(message: TxResult): TxResultProtoMsg;
  registerTypeUrl(): void;
};
/**
 * AccessTuple is the element type of an access list.
 * @name AccessTuple
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.AccessTuple
 */
declare const AccessTuple: {
  typeUrl: string;
  is(o: any): o is AccessTuple;
  isAmino(o: any): o is AccessTupleAmino;
  encode(message: AccessTuple, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): AccessTuple;
  fromPartial(object: DeepPartial<AccessTuple>): AccessTuple;
  fromAmino(object: AccessTupleAmino): AccessTuple;
  toAmino(message: AccessTuple): AccessTupleAmino;
  fromAminoMsg(object: AccessTupleAminoMsg): AccessTuple;
  fromProtoMsg(message: AccessTupleProtoMsg): AccessTuple;
  toProto(message: AccessTuple): Uint8Array;
  toProtoMsg(message: AccessTuple): AccessTupleProtoMsg;
  registerTypeUrl(): void;
};
/**
 * TraceConfig holds extra parameters to trace functions.
 * @name TraceConfig
 * @package ethermint.evm.v1
 * @see proto type: ethermint.evm.v1.TraceConfig
 */
declare const TraceConfig: {
  typeUrl: string;
  is(o: any): o is TraceConfig;
  isAmino(o: any): o is TraceConfigAmino;
  encode(message: TraceConfig, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): TraceConfig;
  fromPartial(object: DeepPartial<TraceConfig>): TraceConfig;
  fromAmino(object: TraceConfigAmino): TraceConfig;
  toAmino(message: TraceConfig): TraceConfigAmino;
  fromAminoMsg(object: TraceConfigAminoMsg): TraceConfig;
  fromProtoMsg(message: TraceConfigProtoMsg): TraceConfig;
  toProto(message: TraceConfig): Uint8Array;
  toProtoMsg(message: TraceConfig): TraceConfigProtoMsg;
  registerTypeUrl(): void;
};
//#endregion
export { AccessTuple, AccessTupleAmino, AccessTupleAminoMsg, AccessTupleProtoMsg, ChainConfig, ChainConfigAmino, ChainConfigAminoMsg, ChainConfigProtoMsg, Log, LogAmino, LogAminoMsg, LogProtoMsg, Params, ParamsAmino, ParamsAminoMsg, ParamsProtoMsg, State, StateAmino, StateAminoMsg, StateProtoMsg, TraceConfig, TraceConfigAmino, TraceConfigAminoMsg, TraceConfigProtoMsg, TransactionLogs, TransactionLogsAmino, TransactionLogsAminoMsg, TransactionLogsProtoMsg, TxResult, TxResultAmino, TxResultAminoMsg, TxResultProtoMsg };