@manifest-network/manifestjs 2.1.0

package/dist/codegen/cosmwasm/wasm/v1/query.d.ts

@@ -0,0 +1,1454 @@
+import { PageRequest, PageRequestAmino, PageRequestSDKType, PageResponse, PageResponseAmino, PageResponseSDKType } from "../../../cosmos/base/query/v1beta1/pagination";
+import { ContractInfo, ContractInfoAmino, ContractInfoSDKType, ContractCodeHistoryEntry, ContractCodeHistoryEntryAmino, ContractCodeHistoryEntrySDKType, Model, ModelAmino, ModelSDKType, AccessConfig, AccessConfigAmino, AccessConfigSDKType, Params, ParamsAmino, ParamsSDKType } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial, Exact } from "../../../helpers";
+import { JsonSafe } from "../../../json-safe";
+/**
+ * QueryContractInfoRequest is the request type for the Query/ContractInfo RPC
+ * method
+ */
+export interface QueryContractInfoRequest {
+    /** address is the address of the contract to query */
+    address: string;
+}
+export interface QueryContractInfoRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryContractInfoRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryContractInfoRequest is the request type for the Query/ContractInfo RPC
+ * method
+ */
+export interface QueryContractInfoRequestAmino {
+    /** address is the address of the contract to query */
+    address?: string;
+}
+export interface QueryContractInfoRequestAminoMsg {
+    type: "wasm/QueryContractInfoRequest";
+    value: QueryContractInfoRequestAmino;
+}
+/**
+ * QueryContractInfoRequest is the request type for the Query/ContractInfo RPC
+ * method
+ */
+export interface QueryContractInfoRequestSDKType {
+    address: string;
+}
+/**
+ * QueryContractInfoResponse is the response type for the Query/ContractInfo RPC
+ * method
+ */
+export interface QueryContractInfoResponse {
+    /** address is the address of the contract */
+    address: string;
+    contractInfo: ContractInfo;
+}
+export interface QueryContractInfoResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryContractInfoResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryContractInfoResponse is the response type for the Query/ContractInfo RPC
+ * method
+ */
+export interface QueryContractInfoResponseAmino {
+    /** address is the address of the contract */
+    address?: string;
+    contract_info: ContractInfoAmino;
+}
+export interface QueryContractInfoResponseAminoMsg {
+    type: "wasm/QueryContractInfoResponse";
+    value: QueryContractInfoResponseAmino;
+}
+/**
+ * QueryContractInfoResponse is the response type for the Query/ContractInfo RPC
+ * method
+ */
+export interface QueryContractInfoResponseSDKType {
+    address: string;
+    contract_info: ContractInfoSDKType;
+}
+/**
+ * QueryContractHistoryRequest is the request type for the Query/ContractHistory
+ * RPC method
+ */
+export interface QueryContractHistoryRequest {
+    /** address is the address of the contract to query */
+    address: string;
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequest;
+}
+export interface QueryContractHistoryRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryContractHistoryRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryContractHistoryRequest is the request type for the Query/ContractHistory
+ * RPC method
+ */
+export interface QueryContractHistoryRequestAmino {
+    /** address is the address of the contract to query */
+    address?: string;
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequestAmino;
+}
+export interface QueryContractHistoryRequestAminoMsg {
+    type: "wasm/QueryContractHistoryRequest";
+    value: QueryContractHistoryRequestAmino;
+}
+/**
+ * QueryContractHistoryRequest is the request type for the Query/ContractHistory
+ * RPC method
+ */
+export interface QueryContractHistoryRequestSDKType {
+    address: string;
+    pagination?: PageRequestSDKType;
+}
+/**
+ * QueryContractHistoryResponse is the response type for the
+ * Query/ContractHistory RPC method
+ */
+export interface QueryContractHistoryResponse {
+    entries: ContractCodeHistoryEntry[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponse;
+}
+export interface QueryContractHistoryResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryContractHistoryResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryContractHistoryResponse is the response type for the
+ * Query/ContractHistory RPC method
+ */
+export interface QueryContractHistoryResponseAmino {
+    entries: ContractCodeHistoryEntryAmino[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponseAmino;
+}
+export interface QueryContractHistoryResponseAminoMsg {
+    type: "wasm/QueryContractHistoryResponse";
+    value: QueryContractHistoryResponseAmino;
+}
+/**
+ * QueryContractHistoryResponse is the response type for the
+ * Query/ContractHistory RPC method
+ */
+export interface QueryContractHistoryResponseSDKType {
+    entries: ContractCodeHistoryEntrySDKType[];
+    pagination?: PageResponseSDKType;
+}
+/**
+ * QueryContractsByCodeRequest is the request type for the Query/ContractsByCode
+ * RPC method
+ */
+export interface QueryContractsByCodeRequest {
+    /** grpc-gateway_out does not support Go style CodeID */
+    codeId: bigint;
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequest;
+}
+export interface QueryContractsByCodeRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryContractsByCodeRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryContractsByCodeRequest is the request type for the Query/ContractsByCode
+ * RPC method
+ */
+export interface QueryContractsByCodeRequestAmino {
+    /** grpc-gateway_out does not support Go style CodeID */
+    code_id?: string;
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequestAmino;
+}
+export interface QueryContractsByCodeRequestAminoMsg {
+    type: "wasm/QueryContractsByCodeRequest";
+    value: QueryContractsByCodeRequestAmino;
+}
+/**
+ * QueryContractsByCodeRequest is the request type for the Query/ContractsByCode
+ * RPC method
+ */
+export interface QueryContractsByCodeRequestSDKType {
+    code_id: bigint;
+    pagination?: PageRequestSDKType;
+}
+/**
+ * QueryContractsByCodeResponse is the response type for the
+ * Query/ContractsByCode RPC method
+ */
+export interface QueryContractsByCodeResponse {
+    /** contracts are a set of contract addresses */
+    contracts: string[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponse;
+}
+export interface QueryContractsByCodeResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryContractsByCodeResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryContractsByCodeResponse is the response type for the
+ * Query/ContractsByCode RPC method
+ */
+export interface QueryContractsByCodeResponseAmino {
+    /** contracts are a set of contract addresses */
+    contracts?: string[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponseAmino;
+}
+export interface QueryContractsByCodeResponseAminoMsg {
+    type: "wasm/QueryContractsByCodeResponse";
+    value: QueryContractsByCodeResponseAmino;
+}
+/**
+ * QueryContractsByCodeResponse is the response type for the
+ * Query/ContractsByCode RPC method
+ */
+export interface QueryContractsByCodeResponseSDKType {
+    contracts: string[];
+    pagination?: PageResponseSDKType;
+}
+/**
+ * QueryAllContractStateRequest is the request type for the
+ * Query/AllContractState RPC method
+ */
+export interface QueryAllContractStateRequest {
+    /** address is the address of the contract */
+    address: string;
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequest;
+}
+export interface QueryAllContractStateRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryAllContractStateRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryAllContractStateRequest is the request type for the
+ * Query/AllContractState RPC method
+ */
+export interface QueryAllContractStateRequestAmino {
+    /** address is the address of the contract */
+    address?: string;
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequestAmino;
+}
+export interface QueryAllContractStateRequestAminoMsg {
+    type: "wasm/QueryAllContractStateRequest";
+    value: QueryAllContractStateRequestAmino;
+}
+/**
+ * QueryAllContractStateRequest is the request type for the
+ * Query/AllContractState RPC method
+ */
+export interface QueryAllContractStateRequestSDKType {
+    address: string;
+    pagination?: PageRequestSDKType;
+}
+/**
+ * QueryAllContractStateResponse is the response type for the
+ * Query/AllContractState RPC method
+ */
+export interface QueryAllContractStateResponse {
+    models: Model[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponse;
+}
+export interface QueryAllContractStateResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryAllContractStateResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryAllContractStateResponse is the response type for the
+ * Query/AllContractState RPC method
+ */
+export interface QueryAllContractStateResponseAmino {
+    models: ModelAmino[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponseAmino;
+}
+export interface QueryAllContractStateResponseAminoMsg {
+    type: "wasm/QueryAllContractStateResponse";
+    value: QueryAllContractStateResponseAmino;
+}
+/**
+ * QueryAllContractStateResponse is the response type for the
+ * Query/AllContractState RPC method
+ */
+export interface QueryAllContractStateResponseSDKType {
+    models: ModelSDKType[];
+    pagination?: PageResponseSDKType;
+}
+/**
+ * QueryRawContractStateRequest is the request type for the
+ * Query/RawContractState RPC method
+ */
+export interface QueryRawContractStateRequest {
+    /** address is the address of the contract */
+    address: string;
+    queryData: Uint8Array;
+}
+export interface QueryRawContractStateRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryRawContractStateRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryRawContractStateRequest is the request type for the
+ * Query/RawContractState RPC method
+ */
+export interface QueryRawContractStateRequestAmino {
+    /** address is the address of the contract */
+    address?: string;
+    query_data?: string;
+}
+export interface QueryRawContractStateRequestAminoMsg {
+    type: "wasm/QueryRawContractStateRequest";
+    value: QueryRawContractStateRequestAmino;
+}
+/**
+ * QueryRawContractStateRequest is the request type for the
+ * Query/RawContractState RPC method
+ */
+export interface QueryRawContractStateRequestSDKType {
+    address: string;
+    query_data: Uint8Array;
+}
+/**
+ * QueryRawContractStateResponse is the response type for the
+ * Query/RawContractState RPC method
+ */
+export interface QueryRawContractStateResponse {
+    /** Data contains the raw store data */
+    data: Uint8Array;
+}
+export interface QueryRawContractStateResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryRawContractStateResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryRawContractStateResponse is the response type for the
+ * Query/RawContractState RPC method
+ */
+export interface QueryRawContractStateResponseAmino {
+    /** Data contains the raw store data */
+    data?: string;
+}
+export interface QueryRawContractStateResponseAminoMsg {
+    type: "wasm/QueryRawContractStateResponse";
+    value: QueryRawContractStateResponseAmino;
+}
+/**
+ * QueryRawContractStateResponse is the response type for the
+ * Query/RawContractState RPC method
+ */
+export interface QueryRawContractStateResponseSDKType {
+    data: Uint8Array;
+}
+/**
+ * QuerySmartContractStateRequest is the request type for the
+ * Query/SmartContractState RPC method
+ */
+export interface QuerySmartContractStateRequest {
+    /** address is the address of the contract */
+    address: string;
+    /** QueryData contains the query data passed to the contract */
+    queryData: Uint8Array;
+}
+export interface QuerySmartContractStateRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QuerySmartContractStateRequest";
+    value: Uint8Array;
+}
+/**
+ * QuerySmartContractStateRequest is the request type for the
+ * Query/SmartContractState RPC method
+ */
+export interface QuerySmartContractStateRequestAmino {
+    /** address is the address of the contract */
+    address?: string;
+    /** QueryData contains the query data passed to the contract */
+    query_data?: any;
+}
+export interface QuerySmartContractStateRequestAminoMsg {
+    type: "wasm/QuerySmartContractStateRequest";
+    value: QuerySmartContractStateRequestAmino;
+}
+/**
+ * QuerySmartContractStateRequest is the request type for the
+ * Query/SmartContractState RPC method
+ */
+export interface QuerySmartContractStateRequestSDKType {
+    address: string;
+    query_data: Uint8Array;
+}
+/**
+ * QuerySmartContractStateResponse is the response type for the
+ * Query/SmartContractState RPC method
+ */
+export interface QuerySmartContractStateResponse {
+    /** Data contains the json data returned from the smart contract */
+    data: Uint8Array;
+}
+export interface QuerySmartContractStateResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QuerySmartContractStateResponse";
+    value: Uint8Array;
+}
+/**
+ * QuerySmartContractStateResponse is the response type for the
+ * Query/SmartContractState RPC method
+ */
+export interface QuerySmartContractStateResponseAmino {
+    /** Data contains the json data returned from the smart contract */
+    data?: any;
+}
+export interface QuerySmartContractStateResponseAminoMsg {
+    type: "wasm/QuerySmartContractStateResponse";
+    value: QuerySmartContractStateResponseAmino;
+}
+/**
+ * QuerySmartContractStateResponse is the response type for the
+ * Query/SmartContractState RPC method
+ */
+export interface QuerySmartContractStateResponseSDKType {
+    data: Uint8Array;
+}
+/** QueryCodeRequest is the request type for the Query/Code RPC method */
+export interface QueryCodeRequest {
+    /** grpc-gateway_out does not support Go style CodeID */
+    codeId: bigint;
+}
+export interface QueryCodeRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryCodeRequest";
+    value: Uint8Array;
+}
+/** QueryCodeRequest is the request type for the Query/Code RPC method */
+export interface QueryCodeRequestAmino {
+    /** grpc-gateway_out does not support Go style CodeID */
+    code_id?: string;
+}
+export interface QueryCodeRequestAminoMsg {
+    type: "wasm/QueryCodeRequest";
+    value: QueryCodeRequestAmino;
+}
+/** QueryCodeRequest is the request type for the Query/Code RPC method */
+export interface QueryCodeRequestSDKType {
+    code_id: bigint;
+}
+/** QueryCodeInfoRequest is the request type for the Query/CodeInfo RPC method */
+export interface QueryCodeInfoRequest {
+    /** grpc-gateway_out does not support Go style CodeID */
+    codeId: bigint;
+}
+export interface QueryCodeInfoRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryCodeInfoRequest";
+    value: Uint8Array;
+}
+/** QueryCodeInfoRequest is the request type for the Query/CodeInfo RPC method */
+export interface QueryCodeInfoRequestAmino {
+    /** grpc-gateway_out does not support Go style CodeID */
+    code_id?: string;
+}
+export interface QueryCodeInfoRequestAminoMsg {
+    type: "wasm/QueryCodeInfoRequest";
+    value: QueryCodeInfoRequestAmino;
+}
+/** QueryCodeInfoRequest is the request type for the Query/CodeInfo RPC method */
+export interface QueryCodeInfoRequestSDKType {
+    code_id: bigint;
+}
+/** QueryCodeInfoResponse is the response type for the Query/CodeInfo RPC method */
+export interface QueryCodeInfoResponse {
+    codeId: bigint;
+    creator: string;
+    checksum: Uint8Array;
+    instantiatePermission: AccessConfig;
+}
+export interface QueryCodeInfoResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryCodeInfoResponse";
+    value: Uint8Array;
+}
+/** QueryCodeInfoResponse is the response type for the Query/CodeInfo RPC method */
+export interface QueryCodeInfoResponseAmino {
+    code_id?: string;
+    creator?: string;
+    checksum?: string;
+    instantiate_permission: AccessConfigAmino;
+}
+export interface QueryCodeInfoResponseAminoMsg {
+    type: "wasm/QueryCodeInfoResponse";
+    value: QueryCodeInfoResponseAmino;
+}
+/** QueryCodeInfoResponse is the response type for the Query/CodeInfo RPC method */
+export interface QueryCodeInfoResponseSDKType {
+    code_id: bigint;
+    creator: string;
+    checksum: Uint8Array;
+    instantiate_permission: AccessConfigSDKType;
+}
+/** CodeInfoResponse contains code meta data from CodeInfo */
+export interface CodeInfoResponse {
+    codeId: bigint;
+    creator: string;
+    dataHash: Uint8Array;
+    instantiatePermission: AccessConfig;
+}
+export interface CodeInfoResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.CodeInfoResponse";
+    value: Uint8Array;
+}
+/** CodeInfoResponse contains code meta data from CodeInfo */
+export interface CodeInfoResponseAmino {
+    code_id: string;
+    creator?: string;
+    data_hash?: string;
+    instantiate_permission: AccessConfigAmino;
+}
+export interface CodeInfoResponseAminoMsg {
+    type: "wasm/CodeInfoResponse";
+    value: CodeInfoResponseAmino;
+}
+/** CodeInfoResponse contains code meta data from CodeInfo */
+export interface CodeInfoResponseSDKType {
+    code_id: bigint;
+    creator: string;
+    data_hash: Uint8Array;
+    instantiate_permission: AccessConfigSDKType;
+}
+/** QueryCodeResponse is the response type for the Query/Code RPC method */
+export interface QueryCodeResponse {
+    codeInfo?: CodeInfoResponse;
+    data: Uint8Array;
+}
+export interface QueryCodeResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryCodeResponse";
+    value: Uint8Array;
+}
+/** QueryCodeResponse is the response type for the Query/Code RPC method */
+export interface QueryCodeResponseAmino {
+    code_info?: CodeInfoResponseAmino;
+    data: string;
+}
+export interface QueryCodeResponseAminoMsg {
+    type: "wasm/QueryCodeResponse";
+    value: QueryCodeResponseAmino;
+}
+/** QueryCodeResponse is the response type for the Query/Code RPC method */
+export interface QueryCodeResponseSDKType {
+    code_info?: CodeInfoResponseSDKType;
+    data: Uint8Array;
+}
+/** QueryCodesRequest is the request type for the Query/Codes RPC method */
+export interface QueryCodesRequest {
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequest;
+}
+export interface QueryCodesRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryCodesRequest";
+    value: Uint8Array;
+}
+/** QueryCodesRequest is the request type for the Query/Codes RPC method */
+export interface QueryCodesRequestAmino {
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequestAmino;
+}
+export interface QueryCodesRequestAminoMsg {
+    type: "wasm/QueryCodesRequest";
+    value: QueryCodesRequestAmino;
+}
+/** QueryCodesRequest is the request type for the Query/Codes RPC method */
+export interface QueryCodesRequestSDKType {
+    pagination?: PageRequestSDKType;
+}
+/** QueryCodesResponse is the response type for the Query/Codes RPC method */
+export interface QueryCodesResponse {
+    codeInfos: CodeInfoResponse[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponse;
+}
+export interface QueryCodesResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryCodesResponse";
+    value: Uint8Array;
+}
+/** QueryCodesResponse is the response type for the Query/Codes RPC method */
+export interface QueryCodesResponseAmino {
+    code_infos: CodeInfoResponseAmino[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponseAmino;
+}
+export interface QueryCodesResponseAminoMsg {
+    type: "wasm/QueryCodesResponse";
+    value: QueryCodesResponseAmino;
+}
+/** QueryCodesResponse is the response type for the Query/Codes RPC method */
+export interface QueryCodesResponseSDKType {
+    code_infos: CodeInfoResponseSDKType[];
+    pagination?: PageResponseSDKType;
+}
+/**
+ * QueryPinnedCodesRequest is the request type for the Query/PinnedCodes
+ * RPC method
+ */
+export interface QueryPinnedCodesRequest {
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequest;
+}
+export interface QueryPinnedCodesRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryPinnedCodesRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryPinnedCodesRequest is the request type for the Query/PinnedCodes
+ * RPC method
+ */
+export interface QueryPinnedCodesRequestAmino {
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequestAmino;
+}
+export interface QueryPinnedCodesRequestAminoMsg {
+    type: "wasm/QueryPinnedCodesRequest";
+    value: QueryPinnedCodesRequestAmino;
+}
+/**
+ * QueryPinnedCodesRequest is the request type for the Query/PinnedCodes
+ * RPC method
+ */
+export interface QueryPinnedCodesRequestSDKType {
+    pagination?: PageRequestSDKType;
+}
+/**
+ * QueryPinnedCodesResponse is the response type for the
+ * Query/PinnedCodes RPC method
+ */
+export interface QueryPinnedCodesResponse {
+    codeIds: bigint[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponse;
+}
+export interface QueryPinnedCodesResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryPinnedCodesResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryPinnedCodesResponse is the response type for the
+ * Query/PinnedCodes RPC method
+ */
+export interface QueryPinnedCodesResponseAmino {
+    code_ids?: string[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponseAmino;
+}
+export interface QueryPinnedCodesResponseAminoMsg {
+    type: "wasm/QueryPinnedCodesResponse";
+    value: QueryPinnedCodesResponseAmino;
+}
+/**
+ * QueryPinnedCodesResponse is the response type for the
+ * Query/PinnedCodes RPC method
+ */
+export interface QueryPinnedCodesResponseSDKType {
+    code_ids: bigint[];
+    pagination?: PageResponseSDKType;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {
+}
+export interface QueryParamsRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryParamsRequest";
+    value: Uint8Array;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequestAmino {
+}
+export interface QueryParamsRequestAminoMsg {
+    type: "wasm/QueryParamsRequest";
+    value: QueryParamsRequestAmino;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequestSDKType {
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponse {
+    /** params defines the parameters of the module. */
+    params: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryParamsResponse";
+    value: Uint8Array;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponseAmino {
+    /** params defines the parameters of the module. */
+    params: ParamsAmino;
+}
+export interface QueryParamsResponseAminoMsg {
+    type: "wasm/QueryParamsResponse";
+    value: QueryParamsResponseAmino;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponseSDKType {
+    params: ParamsSDKType;
+}
+/**
+ * QueryContractsByCreatorRequest is the request type for the
+ * Query/ContractsByCreator RPC method.
+ */
+export interface QueryContractsByCreatorRequest {
+    /** CreatorAddress is the address of contract creator */
+    creatorAddress: string;
+    /** Pagination defines an optional pagination for the request. */
+    pagination?: PageRequest;
+}
+export interface QueryContractsByCreatorRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryContractsByCreatorRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryContractsByCreatorRequest is the request type for the
+ * Query/ContractsByCreator RPC method.
+ */
+export interface QueryContractsByCreatorRequestAmino {
+    /** CreatorAddress is the address of contract creator */
+    creator_address?: string;
+    /** Pagination defines an optional pagination for the request. */
+    pagination?: PageRequestAmino;
+}
+export interface QueryContractsByCreatorRequestAminoMsg {
+    type: "wasm/QueryContractsByCreatorRequest";
+    value: QueryContractsByCreatorRequestAmino;
+}
+/**
+ * QueryContractsByCreatorRequest is the request type for the
+ * Query/ContractsByCreator RPC method.
+ */
+export interface QueryContractsByCreatorRequestSDKType {
+    creator_address: string;
+    pagination?: PageRequestSDKType;
+}
+/**
+ * QueryContractsByCreatorResponse is the response type for the
+ * Query/ContractsByCreator RPC method.
+ */
+export interface QueryContractsByCreatorResponse {
+    /** ContractAddresses result set */
+    contractAddresses: string[];
+    /** Pagination defines the pagination in the response. */
+    pagination?: PageResponse;
+}
+export interface QueryContractsByCreatorResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryContractsByCreatorResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryContractsByCreatorResponse is the response type for the
+ * Query/ContractsByCreator RPC method.
+ */
+export interface QueryContractsByCreatorResponseAmino {
+    /** ContractAddresses result set */
+    contract_addresses?: string[];
+    /** Pagination defines the pagination in the response. */
+    pagination?: PageResponseAmino;
+}
+export interface QueryContractsByCreatorResponseAminoMsg {
+    type: "wasm/QueryContractsByCreatorResponse";
+    value: QueryContractsByCreatorResponseAmino;
+}
+/**
+ * QueryContractsByCreatorResponse is the response type for the
+ * Query/ContractsByCreator RPC method.
+ */
+export interface QueryContractsByCreatorResponseSDKType {
+    contract_addresses: string[];
+    pagination?: PageResponseSDKType;
+}
+/**
+ * QueryWasmLimitsConfigRequest is the request type for the
+ * Query/WasmLimitsConfig RPC method.
+ */
+export interface QueryWasmLimitsConfigRequest {
+}
+export interface QueryWasmLimitsConfigRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryWasmLimitsConfigRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryWasmLimitsConfigRequest is the request type for the
+ * Query/WasmLimitsConfig RPC method.
+ */
+export interface QueryWasmLimitsConfigRequestAmino {
+}
+export interface QueryWasmLimitsConfigRequestAminoMsg {
+    type: "wasm/QueryWasmLimitsConfigRequest";
+    value: QueryWasmLimitsConfigRequestAmino;
+}
+/**
+ * QueryWasmLimitsConfigRequest is the request type for the
+ * Query/WasmLimitsConfig RPC method.
+ */
+export interface QueryWasmLimitsConfigRequestSDKType {
+}
+/**
+ * QueryWasmLimitsConfigResponse is the response type for the
+ * Query/WasmLimitsConfig RPC method. It contains the JSON encoded limits for
+ * static validation of Wasm files.
+ */
+export interface QueryWasmLimitsConfigResponse {
+    config: string;
+}
+export interface QueryWasmLimitsConfigResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryWasmLimitsConfigResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryWasmLimitsConfigResponse is the response type for the
+ * Query/WasmLimitsConfig RPC method. It contains the JSON encoded limits for
+ * static validation of Wasm files.
+ */
+export interface QueryWasmLimitsConfigResponseAmino {
+    config?: string;
+}
+export interface QueryWasmLimitsConfigResponseAminoMsg {
+    type: "wasm/QueryWasmLimitsConfigResponse";
+    value: QueryWasmLimitsConfigResponseAmino;
+}
+/**
+ * QueryWasmLimitsConfigResponse is the response type for the
+ * Query/WasmLimitsConfig RPC method. It contains the JSON encoded limits for
+ * static validation of Wasm files.
+ */
+export interface QueryWasmLimitsConfigResponseSDKType {
+    config: string;
+}
+/**
+ * QueryBuildAddressRequest is the request type for the Query/BuildAddress RPC
+ * method.
+ */
+export interface QueryBuildAddressRequest {
+    /** CodeHash is the hash of the code */
+    codeHash: string;
+    /** CreatorAddress is the address of the contract instantiator */
+    creatorAddress: string;
+    /** Salt is a hex encoded salt */
+    salt: string;
+    /**
+     * InitArgs are optional json encoded init args to be used in contract address
+     * building if provided
+     */
+    initArgs: Uint8Array;
+}
+export interface QueryBuildAddressRequestProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryBuildAddressRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryBuildAddressRequest is the request type for the Query/BuildAddress RPC
+ * method.
+ */
+export interface QueryBuildAddressRequestAmino {
+    /** CodeHash is the hash of the code */
+    code_hash?: string;
+    /** CreatorAddress is the address of the contract instantiator */
+    creator_address?: string;
+    /** Salt is a hex encoded salt */
+    salt?: string;
+    /**
+     * InitArgs are optional json encoded init args to be used in contract address
+     * building if provided
+     */
+    init_args?: string;
+}
+export interface QueryBuildAddressRequestAminoMsg {
+    type: "wasm/QueryBuildAddressRequest";
+    value: QueryBuildAddressRequestAmino;
+}
+/**
+ * QueryBuildAddressRequest is the request type for the Query/BuildAddress RPC
+ * method.
+ */
+export interface QueryBuildAddressRequestSDKType {
+    code_hash: string;
+    creator_address: string;
+    salt: string;
+    init_args: Uint8Array;
+}
+/**
+ * QueryBuildAddressResponse is the response type for the Query/BuildAddress RPC
+ * method.
+ */
+export interface QueryBuildAddressResponse {
+    /** Address is the contract address */
+    address: string;
+}
+export interface QueryBuildAddressResponseProtoMsg {
+    typeUrl: "/cosmwasm.wasm.v1.QueryBuildAddressResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryBuildAddressResponse is the response type for the Query/BuildAddress RPC
+ * method.
+ */
+export interface QueryBuildAddressResponseAmino {
+    /** Address is the contract address */
+    address?: string;
+}
+export interface QueryBuildAddressResponseAminoMsg {
+    type: "wasm/QueryBuildAddressResponse";
+    value: QueryBuildAddressResponseAmino;
+}
+/**
+ * QueryBuildAddressResponse is the response type for the Query/BuildAddress RPC
+ * method.
+ */
+export interface QueryBuildAddressResponseSDKType {
+    address: string;
+}
+export declare const QueryContractInfoRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryContractInfoRequest;
+    isSDK(o: any): o is QueryContractInfoRequestSDKType;
+    isAmino(o: any): o is QueryContractInfoRequestAmino;
+    encode(message: QueryContractInfoRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractInfoRequest;
+    fromJSON(object: any): QueryContractInfoRequest;
+    toJSON(message: QueryContractInfoRequest): JsonSafe<QueryContractInfoRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryContractInfoRequest>, I>>(object: I): QueryContractInfoRequest;
+    fromAmino(object: QueryContractInfoRequestAmino): QueryContractInfoRequest;
+    toAmino(message: QueryContractInfoRequest): QueryContractInfoRequestAmino;
+    fromAminoMsg(object: QueryContractInfoRequestAminoMsg): QueryContractInfoRequest;
+    toAminoMsg(message: QueryContractInfoRequest): QueryContractInfoRequestAminoMsg;
+    fromProtoMsg(message: QueryContractInfoRequestProtoMsg): QueryContractInfoRequest;
+    toProto(message: QueryContractInfoRequest): Uint8Array;
+    toProtoMsg(message: QueryContractInfoRequest): QueryContractInfoRequestProtoMsg;
+};
+export declare const QueryContractInfoResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryContractInfoResponse;
+    isSDK(o: any): o is QueryContractInfoResponseSDKType;
+    isAmino(o: any): o is QueryContractInfoResponseAmino;
+    encode(message: QueryContractInfoResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractInfoResponse;
+    fromJSON(object: any): QueryContractInfoResponse;
+    toJSON(message: QueryContractInfoResponse): JsonSafe<QueryContractInfoResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryContractInfoResponse>, I>>(object: I): QueryContractInfoResponse;
+    fromAmino(object: QueryContractInfoResponseAmino): QueryContractInfoResponse;
+    toAmino(message: QueryContractInfoResponse): QueryContractInfoResponseAmino;
+    fromAminoMsg(object: QueryContractInfoResponseAminoMsg): QueryContractInfoResponse;
+    toAminoMsg(message: QueryContractInfoResponse): QueryContractInfoResponseAminoMsg;
+    fromProtoMsg(message: QueryContractInfoResponseProtoMsg): QueryContractInfoResponse;
+    toProto(message: QueryContractInfoResponse): Uint8Array;
+    toProtoMsg(message: QueryContractInfoResponse): QueryContractInfoResponseProtoMsg;
+};
+export declare const QueryContractHistoryRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryContractHistoryRequest;
+    isSDK(o: any): o is QueryContractHistoryRequestSDKType;
+    isAmino(o: any): o is QueryContractHistoryRequestAmino;
+    encode(message: QueryContractHistoryRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractHistoryRequest;
+    fromJSON(object: any): QueryContractHistoryRequest;
+    toJSON(message: QueryContractHistoryRequest): JsonSafe<QueryContractHistoryRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryContractHistoryRequest>, I>>(object: I): QueryContractHistoryRequest;
+    fromAmino(object: QueryContractHistoryRequestAmino): QueryContractHistoryRequest;
+    toAmino(message: QueryContractHistoryRequest): QueryContractHistoryRequestAmino;
+    fromAminoMsg(object: QueryContractHistoryRequestAminoMsg): QueryContractHistoryRequest;
+    toAminoMsg(message: QueryContractHistoryRequest): QueryContractHistoryRequestAminoMsg;
+    fromProtoMsg(message: QueryContractHistoryRequestProtoMsg): QueryContractHistoryRequest;
+    toProto(message: QueryContractHistoryRequest): Uint8Array;
+    toProtoMsg(message: QueryContractHistoryRequest): QueryContractHistoryRequestProtoMsg;
+};
+export declare const QueryContractHistoryResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryContractHistoryResponse;
+    isSDK(o: any): o is QueryContractHistoryResponseSDKType;
+    isAmino(o: any): o is QueryContractHistoryResponseAmino;
+    encode(message: QueryContractHistoryResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractHistoryResponse;
+    fromJSON(object: any): QueryContractHistoryResponse;
+    toJSON(message: QueryContractHistoryResponse): JsonSafe<QueryContractHistoryResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryContractHistoryResponse>, I>>(object: I): QueryContractHistoryResponse;
+    fromAmino(object: QueryContractHistoryResponseAmino): QueryContractHistoryResponse;
+    toAmino(message: QueryContractHistoryResponse): QueryContractHistoryResponseAmino;
+    fromAminoMsg(object: QueryContractHistoryResponseAminoMsg): QueryContractHistoryResponse;
+    toAminoMsg(message: QueryContractHistoryResponse): QueryContractHistoryResponseAminoMsg;
+    fromProtoMsg(message: QueryContractHistoryResponseProtoMsg): QueryContractHistoryResponse;
+    toProto(message: QueryContractHistoryResponse): Uint8Array;
+    toProtoMsg(message: QueryContractHistoryResponse): QueryContractHistoryResponseProtoMsg;
+};
+export declare const QueryContractsByCodeRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryContractsByCodeRequest;
+    isSDK(o: any): o is QueryContractsByCodeRequestSDKType;
+    isAmino(o: any): o is QueryContractsByCodeRequestAmino;
+    encode(message: QueryContractsByCodeRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractsByCodeRequest;
+    fromJSON(object: any): QueryContractsByCodeRequest;
+    toJSON(message: QueryContractsByCodeRequest): JsonSafe<QueryContractsByCodeRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryContractsByCodeRequest>, I>>(object: I): QueryContractsByCodeRequest;
+    fromAmino(object: QueryContractsByCodeRequestAmino): QueryContractsByCodeRequest;
+    toAmino(message: QueryContractsByCodeRequest): QueryContractsByCodeRequestAmino;
+    fromAminoMsg(object: QueryContractsByCodeRequestAminoMsg): QueryContractsByCodeRequest;
+    toAminoMsg(message: QueryContractsByCodeRequest): QueryContractsByCodeRequestAminoMsg;
+    fromProtoMsg(message: QueryContractsByCodeRequestProtoMsg): QueryContractsByCodeRequest;
+    toProto(message: QueryContractsByCodeRequest): Uint8Array;
+    toProtoMsg(message: QueryContractsByCodeRequest): QueryContractsByCodeRequestProtoMsg;
+};
+export declare const QueryContractsByCodeResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryContractsByCodeResponse;
+    isSDK(o: any): o is QueryContractsByCodeResponseSDKType;
+    isAmino(o: any): o is QueryContractsByCodeResponseAmino;
+    encode(message: QueryContractsByCodeResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractsByCodeResponse;
+    fromJSON(object: any): QueryContractsByCodeResponse;
+    toJSON(message: QueryContractsByCodeResponse): JsonSafe<QueryContractsByCodeResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryContractsByCodeResponse>, I>>(object: I): QueryContractsByCodeResponse;
+    fromAmino(object: QueryContractsByCodeResponseAmino): QueryContractsByCodeResponse;
+    toAmino(message: QueryContractsByCodeResponse): QueryContractsByCodeResponseAmino;
+    fromAminoMsg(object: QueryContractsByCodeResponseAminoMsg): QueryContractsByCodeResponse;
+    toAminoMsg(message: QueryContractsByCodeResponse): QueryContractsByCodeResponseAminoMsg;
+    fromProtoMsg(message: QueryContractsByCodeResponseProtoMsg): QueryContractsByCodeResponse;
+    toProto(message: QueryContractsByCodeResponse): Uint8Array;
+    toProtoMsg(message: QueryContractsByCodeResponse): QueryContractsByCodeResponseProtoMsg;
+};
+export declare const QueryAllContractStateRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryAllContractStateRequest;
+    isSDK(o: any): o is QueryAllContractStateRequestSDKType;
+    isAmino(o: any): o is QueryAllContractStateRequestAmino;
+    encode(message: QueryAllContractStateRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryAllContractStateRequest;
+    fromJSON(object: any): QueryAllContractStateRequest;
+    toJSON(message: QueryAllContractStateRequest): JsonSafe<QueryAllContractStateRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryAllContractStateRequest>, I>>(object: I): QueryAllContractStateRequest;
+    fromAmino(object: QueryAllContractStateRequestAmino): QueryAllContractStateRequest;
+    toAmino(message: QueryAllContractStateRequest): QueryAllContractStateRequestAmino;
+    fromAminoMsg(object: QueryAllContractStateRequestAminoMsg): QueryAllContractStateRequest;
+    toAminoMsg(message: QueryAllContractStateRequest): QueryAllContractStateRequestAminoMsg;
+    fromProtoMsg(message: QueryAllContractStateRequestProtoMsg): QueryAllContractStateRequest;
+    toProto(message: QueryAllContractStateRequest): Uint8Array;
+    toProtoMsg(message: QueryAllContractStateRequest): QueryAllContractStateRequestProtoMsg;
+};
+export declare const QueryAllContractStateResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryAllContractStateResponse;
+    isSDK(o: any): o is QueryAllContractStateResponseSDKType;
+    isAmino(o: any): o is QueryAllContractStateResponseAmino;
+    encode(message: QueryAllContractStateResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryAllContractStateResponse;
+    fromJSON(object: any): QueryAllContractStateResponse;
+    toJSON(message: QueryAllContractStateResponse): JsonSafe<QueryAllContractStateResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryAllContractStateResponse>, I>>(object: I): QueryAllContractStateResponse;
+    fromAmino(object: QueryAllContractStateResponseAmino): QueryAllContractStateResponse;
+    toAmino(message: QueryAllContractStateResponse): QueryAllContractStateResponseAmino;
+    fromAminoMsg(object: QueryAllContractStateResponseAminoMsg): QueryAllContractStateResponse;
+    toAminoMsg(message: QueryAllContractStateResponse): QueryAllContractStateResponseAminoMsg;
+    fromProtoMsg(message: QueryAllContractStateResponseProtoMsg): QueryAllContractStateResponse;
+    toProto(message: QueryAllContractStateResponse): Uint8Array;
+    toProtoMsg(message: QueryAllContractStateResponse): QueryAllContractStateResponseProtoMsg;
+};
+export declare const QueryRawContractStateRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryRawContractStateRequest;
+    isSDK(o: any): o is QueryRawContractStateRequestSDKType;
+    isAmino(o: any): o is QueryRawContractStateRequestAmino;
+    encode(message: QueryRawContractStateRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryRawContractStateRequest;
+    fromJSON(object: any): QueryRawContractStateRequest;
+    toJSON(message: QueryRawContractStateRequest): JsonSafe<QueryRawContractStateRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryRawContractStateRequest>, I>>(object: I): QueryRawContractStateRequest;
+    fromAmino(object: QueryRawContractStateRequestAmino): QueryRawContractStateRequest;
+    toAmino(message: QueryRawContractStateRequest): QueryRawContractStateRequestAmino;
+    fromAminoMsg(object: QueryRawContractStateRequestAminoMsg): QueryRawContractStateRequest;
+    toAminoMsg(message: QueryRawContractStateRequest): QueryRawContractStateRequestAminoMsg;
+    fromProtoMsg(message: QueryRawContractStateRequestProtoMsg): QueryRawContractStateRequest;
+    toProto(message: QueryRawContractStateRequest): Uint8Array;
+    toProtoMsg(message: QueryRawContractStateRequest): QueryRawContractStateRequestProtoMsg;
+};
+export declare const QueryRawContractStateResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryRawContractStateResponse;
+    isSDK(o: any): o is QueryRawContractStateResponseSDKType;
+    isAmino(o: any): o is QueryRawContractStateResponseAmino;
+    encode(message: QueryRawContractStateResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryRawContractStateResponse;
+    fromJSON(object: any): QueryRawContractStateResponse;
+    toJSON(message: QueryRawContractStateResponse): JsonSafe<QueryRawContractStateResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryRawContractStateResponse>, I>>(object: I): QueryRawContractStateResponse;
+    fromAmino(object: QueryRawContractStateResponseAmino): QueryRawContractStateResponse;
+    toAmino(message: QueryRawContractStateResponse): QueryRawContractStateResponseAmino;
+    fromAminoMsg(object: QueryRawContractStateResponseAminoMsg): QueryRawContractStateResponse;
+    toAminoMsg(message: QueryRawContractStateResponse): QueryRawContractStateResponseAminoMsg;
+    fromProtoMsg(message: QueryRawContractStateResponseProtoMsg): QueryRawContractStateResponse;
+    toProto(message: QueryRawContractStateResponse): Uint8Array;
+    toProtoMsg(message: QueryRawContractStateResponse): QueryRawContractStateResponseProtoMsg;
+};
+export declare const QuerySmartContractStateRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QuerySmartContractStateRequest;
+    isSDK(o: any): o is QuerySmartContractStateRequestSDKType;
+    isAmino(o: any): o is QuerySmartContractStateRequestAmino;
+    encode(message: QuerySmartContractStateRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QuerySmartContractStateRequest;
+    fromJSON(object: any): QuerySmartContractStateRequest;
+    toJSON(message: QuerySmartContractStateRequest): JsonSafe<QuerySmartContractStateRequest>;
+    fromPartial<I extends Exact<DeepPartial<QuerySmartContractStateRequest>, I>>(object: I): QuerySmartContractStateRequest;
+    fromAmino(object: QuerySmartContractStateRequestAmino): QuerySmartContractStateRequest;
+    toAmino(message: QuerySmartContractStateRequest): QuerySmartContractStateRequestAmino;
+    fromAminoMsg(object: QuerySmartContractStateRequestAminoMsg): QuerySmartContractStateRequest;
+    toAminoMsg(message: QuerySmartContractStateRequest): QuerySmartContractStateRequestAminoMsg;
+    fromProtoMsg(message: QuerySmartContractStateRequestProtoMsg): QuerySmartContractStateRequest;
+    toProto(message: QuerySmartContractStateRequest): Uint8Array;
+    toProtoMsg(message: QuerySmartContractStateRequest): QuerySmartContractStateRequestProtoMsg;
+};
+export declare const QuerySmartContractStateResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QuerySmartContractStateResponse;
+    isSDK(o: any): o is QuerySmartContractStateResponseSDKType;
+    isAmino(o: any): o is QuerySmartContractStateResponseAmino;
+    encode(message: QuerySmartContractStateResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QuerySmartContractStateResponse;
+    fromJSON(object: any): QuerySmartContractStateResponse;
+    toJSON(message: QuerySmartContractStateResponse): JsonSafe<QuerySmartContractStateResponse>;
+    fromPartial<I extends Exact<DeepPartial<QuerySmartContractStateResponse>, I>>(object: I): QuerySmartContractStateResponse;
+    fromAmino(object: QuerySmartContractStateResponseAmino): QuerySmartContractStateResponse;
+    toAmino(message: QuerySmartContractStateResponse): QuerySmartContractStateResponseAmino;
+    fromAminoMsg(object: QuerySmartContractStateResponseAminoMsg): QuerySmartContractStateResponse;
+    toAminoMsg(message: QuerySmartContractStateResponse): QuerySmartContractStateResponseAminoMsg;
+    fromProtoMsg(message: QuerySmartContractStateResponseProtoMsg): QuerySmartContractStateResponse;
+    toProto(message: QuerySmartContractStateResponse): Uint8Array;
+    toProtoMsg(message: QuerySmartContractStateResponse): QuerySmartContractStateResponseProtoMsg;
+};
+export declare const QueryCodeRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryCodeRequest;
+    isSDK(o: any): o is QueryCodeRequestSDKType;
+    isAmino(o: any): o is QueryCodeRequestAmino;
+    encode(message: QueryCodeRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodeRequest;
+    fromJSON(object: any): QueryCodeRequest;
+    toJSON(message: QueryCodeRequest): JsonSafe<QueryCodeRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryCodeRequest>, I>>(object: I): QueryCodeRequest;
+    fromAmino(object: QueryCodeRequestAmino): QueryCodeRequest;
+    toAmino(message: QueryCodeRequest): QueryCodeRequestAmino;
+    fromAminoMsg(object: QueryCodeRequestAminoMsg): QueryCodeRequest;
+    toAminoMsg(message: QueryCodeRequest): QueryCodeRequestAminoMsg;
+    fromProtoMsg(message: QueryCodeRequestProtoMsg): QueryCodeRequest;
+    toProto(message: QueryCodeRequest): Uint8Array;
+    toProtoMsg(message: QueryCodeRequest): QueryCodeRequestProtoMsg;
+};
+export declare const QueryCodeInfoRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryCodeInfoRequest;
+    isSDK(o: any): o is QueryCodeInfoRequestSDKType;
+    isAmino(o: any): o is QueryCodeInfoRequestAmino;
+    encode(message: QueryCodeInfoRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodeInfoRequest;
+    fromJSON(object: any): QueryCodeInfoRequest;
+    toJSON(message: QueryCodeInfoRequest): JsonSafe<QueryCodeInfoRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryCodeInfoRequest>, I>>(object: I): QueryCodeInfoRequest;
+    fromAmino(object: QueryCodeInfoRequestAmino): QueryCodeInfoRequest;
+    toAmino(message: QueryCodeInfoRequest): QueryCodeInfoRequestAmino;
+    fromAminoMsg(object: QueryCodeInfoRequestAminoMsg): QueryCodeInfoRequest;
+    toAminoMsg(message: QueryCodeInfoRequest): QueryCodeInfoRequestAminoMsg;
+    fromProtoMsg(message: QueryCodeInfoRequestProtoMsg): QueryCodeInfoRequest;
+    toProto(message: QueryCodeInfoRequest): Uint8Array;
+    toProtoMsg(message: QueryCodeInfoRequest): QueryCodeInfoRequestProtoMsg;
+};
+export declare const QueryCodeInfoResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryCodeInfoResponse;
+    isSDK(o: any): o is QueryCodeInfoResponseSDKType;
+    isAmino(o: any): o is QueryCodeInfoResponseAmino;
+    encode(message: QueryCodeInfoResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodeInfoResponse;
+    fromJSON(object: any): QueryCodeInfoResponse;
+    toJSON(message: QueryCodeInfoResponse): JsonSafe<QueryCodeInfoResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryCodeInfoResponse>, I>>(object: I): QueryCodeInfoResponse;
+    fromAmino(object: QueryCodeInfoResponseAmino): QueryCodeInfoResponse;
+    toAmino(message: QueryCodeInfoResponse): QueryCodeInfoResponseAmino;
+    fromAminoMsg(object: QueryCodeInfoResponseAminoMsg): QueryCodeInfoResponse;
+    toAminoMsg(message: QueryCodeInfoResponse): QueryCodeInfoResponseAminoMsg;
+    fromProtoMsg(message: QueryCodeInfoResponseProtoMsg): QueryCodeInfoResponse;
+    toProto(message: QueryCodeInfoResponse): Uint8Array;
+    toProtoMsg(message: QueryCodeInfoResponse): QueryCodeInfoResponseProtoMsg;
+};
+export declare const CodeInfoResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is CodeInfoResponse;
+    isSDK(o: any): o is CodeInfoResponseSDKType;
+    isAmino(o: any): o is CodeInfoResponseAmino;
+    encode(message: CodeInfoResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CodeInfoResponse;
+    fromJSON(object: any): CodeInfoResponse;
+    toJSON(message: CodeInfoResponse): JsonSafe<CodeInfoResponse>;
+    fromPartial<I extends Exact<DeepPartial<CodeInfoResponse>, I>>(object: I): CodeInfoResponse;
+    fromAmino(object: CodeInfoResponseAmino): CodeInfoResponse;
+    toAmino(message: CodeInfoResponse): CodeInfoResponseAmino;
+    fromAminoMsg(object: CodeInfoResponseAminoMsg): CodeInfoResponse;
+    toAminoMsg(message: CodeInfoResponse): CodeInfoResponseAminoMsg;
+    fromProtoMsg(message: CodeInfoResponseProtoMsg): CodeInfoResponse;
+    toProto(message: CodeInfoResponse): Uint8Array;
+    toProtoMsg(message: CodeInfoResponse): CodeInfoResponseProtoMsg;
+};
+export declare const QueryCodeResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryCodeResponse;
+    isSDK(o: any): o is QueryCodeResponseSDKType;
+    isAmino(o: any): o is QueryCodeResponseAmino;
+    encode(message: QueryCodeResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodeResponse;
+    fromJSON(object: any): QueryCodeResponse;
+    toJSON(message: QueryCodeResponse): JsonSafe<QueryCodeResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryCodeResponse>, I>>(object: I): QueryCodeResponse;
+    fromAmino(object: QueryCodeResponseAmino): QueryCodeResponse;
+    toAmino(message: QueryCodeResponse): QueryCodeResponseAmino;
+    fromAminoMsg(object: QueryCodeResponseAminoMsg): QueryCodeResponse;
+    toAminoMsg(message: QueryCodeResponse): QueryCodeResponseAminoMsg;
+    fromProtoMsg(message: QueryCodeResponseProtoMsg): QueryCodeResponse;
+    toProto(message: QueryCodeResponse): Uint8Array;
+    toProtoMsg(message: QueryCodeResponse): QueryCodeResponseProtoMsg;
+};
+export declare const QueryCodesRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryCodesRequest;
+    isSDK(o: any): o is QueryCodesRequestSDKType;
+    isAmino(o: any): o is QueryCodesRequestAmino;
+    encode(message: QueryCodesRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodesRequest;
+    fromJSON(object: any): QueryCodesRequest;
+    toJSON(message: QueryCodesRequest): JsonSafe<QueryCodesRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryCodesRequest>, I>>(object: I): QueryCodesRequest;
+    fromAmino(object: QueryCodesRequestAmino): QueryCodesRequest;
+    toAmino(message: QueryCodesRequest): QueryCodesRequestAmino;
+    fromAminoMsg(object: QueryCodesRequestAminoMsg): QueryCodesRequest;
+    toAminoMsg(message: QueryCodesRequest): QueryCodesRequestAminoMsg;
+    fromProtoMsg(message: QueryCodesRequestProtoMsg): QueryCodesRequest;
+    toProto(message: QueryCodesRequest): Uint8Array;
+    toProtoMsg(message: QueryCodesRequest): QueryCodesRequestProtoMsg;
+};
+export declare const QueryCodesResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryCodesResponse;
+    isSDK(o: any): o is QueryCodesResponseSDKType;
+    isAmino(o: any): o is QueryCodesResponseAmino;
+    encode(message: QueryCodesResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodesResponse;
+    fromJSON(object: any): QueryCodesResponse;
+    toJSON(message: QueryCodesResponse): JsonSafe<QueryCodesResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryCodesResponse>, I>>(object: I): QueryCodesResponse;
+    fromAmino(object: QueryCodesResponseAmino): QueryCodesResponse;
+    toAmino(message: QueryCodesResponse): QueryCodesResponseAmino;
+    fromAminoMsg(object: QueryCodesResponseAminoMsg): QueryCodesResponse;
+    toAminoMsg(message: QueryCodesResponse): QueryCodesResponseAminoMsg;
+    fromProtoMsg(message: QueryCodesResponseProtoMsg): QueryCodesResponse;
+    toProto(message: QueryCodesResponse): Uint8Array;
+    toProtoMsg(message: QueryCodesResponse): QueryCodesResponseProtoMsg;
+};
+export declare const QueryPinnedCodesRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryPinnedCodesRequest;
+    isSDK(o: any): o is QueryPinnedCodesRequestSDKType;
+    isAmino(o: any): o is QueryPinnedCodesRequestAmino;
+    encode(message: QueryPinnedCodesRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryPinnedCodesRequest;
+    fromJSON(object: any): QueryPinnedCodesRequest;
+    toJSON(message: QueryPinnedCodesRequest): JsonSafe<QueryPinnedCodesRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryPinnedCodesRequest>, I>>(object: I): QueryPinnedCodesRequest;
+    fromAmino(object: QueryPinnedCodesRequestAmino): QueryPinnedCodesRequest;
+    toAmino(message: QueryPinnedCodesRequest): QueryPinnedCodesRequestAmino;
+    fromAminoMsg(object: QueryPinnedCodesRequestAminoMsg): QueryPinnedCodesRequest;
+    toAminoMsg(message: QueryPinnedCodesRequest): QueryPinnedCodesRequestAminoMsg;
+    fromProtoMsg(message: QueryPinnedCodesRequestProtoMsg): QueryPinnedCodesRequest;
+    toProto(message: QueryPinnedCodesRequest): Uint8Array;
+    toProtoMsg(message: QueryPinnedCodesRequest): QueryPinnedCodesRequestProtoMsg;
+};
+export declare const QueryPinnedCodesResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryPinnedCodesResponse;
+    isSDK(o: any): o is QueryPinnedCodesResponseSDKType;
+    isAmino(o: any): o is QueryPinnedCodesResponseAmino;
+    encode(message: QueryPinnedCodesResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryPinnedCodesResponse;
+    fromJSON(object: any): QueryPinnedCodesResponse;
+    toJSON(message: QueryPinnedCodesResponse): JsonSafe<QueryPinnedCodesResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryPinnedCodesResponse>, I>>(object: I): QueryPinnedCodesResponse;
+    fromAmino(object: QueryPinnedCodesResponseAmino): QueryPinnedCodesResponse;
+    toAmino(message: QueryPinnedCodesResponse): QueryPinnedCodesResponseAmino;
+    fromAminoMsg(object: QueryPinnedCodesResponseAminoMsg): QueryPinnedCodesResponse;
+    toAminoMsg(message: QueryPinnedCodesResponse): QueryPinnedCodesResponseAminoMsg;
+    fromProtoMsg(message: QueryPinnedCodesResponseProtoMsg): QueryPinnedCodesResponse;
+    toProto(message: QueryPinnedCodesResponse): Uint8Array;
+    toProtoMsg(message: QueryPinnedCodesResponse): QueryPinnedCodesResponseProtoMsg;
+};
+export declare const QueryParamsRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryParamsRequest;
+    isSDK(o: any): o is QueryParamsRequestSDKType;
+    isAmino(o: any): o is QueryParamsRequestAmino;
+    encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest;
+    fromJSON(_: any): QueryParamsRequest;
+    toJSON(_: QueryParamsRequest): JsonSafe<QueryParamsRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryParamsRequest>, I>>(_: I): QueryParamsRequest;
+    fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
+    toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
+    fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
+    toAminoMsg(message: QueryParamsRequest): QueryParamsRequestAminoMsg;
+    fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
+    toProto(message: QueryParamsRequest): Uint8Array;
+    toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
+};
+export declare const QueryParamsResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryParamsResponse;
+    isSDK(o: any): o is QueryParamsResponseSDKType;
+    isAmino(o: any): o is QueryParamsResponseAmino;
+    encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse;
+    fromJSON(object: any): QueryParamsResponse;
+    toJSON(message: QueryParamsResponse): JsonSafe<QueryParamsResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryParamsResponse>, I>>(object: I): QueryParamsResponse;
+    fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
+    toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
+    fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
+    toAminoMsg(message: QueryParamsResponse): QueryParamsResponseAminoMsg;
+    fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
+    toProto(message: QueryParamsResponse): Uint8Array;
+    toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
+};
+export declare const QueryContractsByCreatorRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryContractsByCreatorRequest;
+    isSDK(o: any): o is QueryContractsByCreatorRequestSDKType;
+    isAmino(o: any): o is QueryContractsByCreatorRequestAmino;
+    encode(message: QueryContractsByCreatorRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractsByCreatorRequest;
+    fromJSON(object: any): QueryContractsByCreatorRequest;
+    toJSON(message: QueryContractsByCreatorRequest): JsonSafe<QueryContractsByCreatorRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryContractsByCreatorRequest>, I>>(object: I): QueryContractsByCreatorRequest;
+    fromAmino(object: QueryContractsByCreatorRequestAmino): QueryContractsByCreatorRequest;
+    toAmino(message: QueryContractsByCreatorRequest): QueryContractsByCreatorRequestAmino;
+    fromAminoMsg(object: QueryContractsByCreatorRequestAminoMsg): QueryContractsByCreatorRequest;
+    toAminoMsg(message: QueryContractsByCreatorRequest): QueryContractsByCreatorRequestAminoMsg;
+    fromProtoMsg(message: QueryContractsByCreatorRequestProtoMsg): QueryContractsByCreatorRequest;
+    toProto(message: QueryContractsByCreatorRequest): Uint8Array;
+    toProtoMsg(message: QueryContractsByCreatorRequest): QueryContractsByCreatorRequestProtoMsg;
+};
+export declare const QueryContractsByCreatorResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryContractsByCreatorResponse;
+    isSDK(o: any): o is QueryContractsByCreatorResponseSDKType;
+    isAmino(o: any): o is QueryContractsByCreatorResponseAmino;
+    encode(message: QueryContractsByCreatorResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractsByCreatorResponse;
+    fromJSON(object: any): QueryContractsByCreatorResponse;
+    toJSON(message: QueryContractsByCreatorResponse): JsonSafe<QueryContractsByCreatorResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryContractsByCreatorResponse>, I>>(object: I): QueryContractsByCreatorResponse;
+    fromAmino(object: QueryContractsByCreatorResponseAmino): QueryContractsByCreatorResponse;
+    toAmino(message: QueryContractsByCreatorResponse): QueryContractsByCreatorResponseAmino;
+    fromAminoMsg(object: QueryContractsByCreatorResponseAminoMsg): QueryContractsByCreatorResponse;
+    toAminoMsg(message: QueryContractsByCreatorResponse): QueryContractsByCreatorResponseAminoMsg;
+    fromProtoMsg(message: QueryContractsByCreatorResponseProtoMsg): QueryContractsByCreatorResponse;
+    toProto(message: QueryContractsByCreatorResponse): Uint8Array;
+    toProtoMsg(message: QueryContractsByCreatorResponse): QueryContractsByCreatorResponseProtoMsg;
+};
+export declare const QueryWasmLimitsConfigRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryWasmLimitsConfigRequest;
+    isSDK(o: any): o is QueryWasmLimitsConfigRequestSDKType;
+    isAmino(o: any): o is QueryWasmLimitsConfigRequestAmino;
+    encode(_: QueryWasmLimitsConfigRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryWasmLimitsConfigRequest;
+    fromJSON(_: any): QueryWasmLimitsConfigRequest;
+    toJSON(_: QueryWasmLimitsConfigRequest): JsonSafe<QueryWasmLimitsConfigRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryWasmLimitsConfigRequest>, I>>(_: I): QueryWasmLimitsConfigRequest;
+    fromAmino(_: QueryWasmLimitsConfigRequestAmino): QueryWasmLimitsConfigRequest;
+    toAmino(_: QueryWasmLimitsConfigRequest): QueryWasmLimitsConfigRequestAmino;
+    fromAminoMsg(object: QueryWasmLimitsConfigRequestAminoMsg): QueryWasmLimitsConfigRequest;
+    toAminoMsg(message: QueryWasmLimitsConfigRequest): QueryWasmLimitsConfigRequestAminoMsg;
+    fromProtoMsg(message: QueryWasmLimitsConfigRequestProtoMsg): QueryWasmLimitsConfigRequest;
+    toProto(message: QueryWasmLimitsConfigRequest): Uint8Array;
+    toProtoMsg(message: QueryWasmLimitsConfigRequest): QueryWasmLimitsConfigRequestProtoMsg;
+};
+export declare const QueryWasmLimitsConfigResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryWasmLimitsConfigResponse;
+    isSDK(o: any): o is QueryWasmLimitsConfigResponseSDKType;
+    isAmino(o: any): o is QueryWasmLimitsConfigResponseAmino;
+    encode(message: QueryWasmLimitsConfigResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryWasmLimitsConfigResponse;
+    fromJSON(object: any): QueryWasmLimitsConfigResponse;
+    toJSON(message: QueryWasmLimitsConfigResponse): JsonSafe<QueryWasmLimitsConfigResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryWasmLimitsConfigResponse>, I>>(object: I): QueryWasmLimitsConfigResponse;
+    fromAmino(object: QueryWasmLimitsConfigResponseAmino): QueryWasmLimitsConfigResponse;
+    toAmino(message: QueryWasmLimitsConfigResponse): QueryWasmLimitsConfigResponseAmino;
+    fromAminoMsg(object: QueryWasmLimitsConfigResponseAminoMsg): QueryWasmLimitsConfigResponse;
+    toAminoMsg(message: QueryWasmLimitsConfigResponse): QueryWasmLimitsConfigResponseAminoMsg;
+    fromProtoMsg(message: QueryWasmLimitsConfigResponseProtoMsg): QueryWasmLimitsConfigResponse;
+    toProto(message: QueryWasmLimitsConfigResponse): Uint8Array;
+    toProtoMsg(message: QueryWasmLimitsConfigResponse): QueryWasmLimitsConfigResponseProtoMsg;
+};
+export declare const QueryBuildAddressRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryBuildAddressRequest;
+    isSDK(o: any): o is QueryBuildAddressRequestSDKType;
+    isAmino(o: any): o is QueryBuildAddressRequestAmino;
+    encode(message: QueryBuildAddressRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryBuildAddressRequest;
+    fromJSON(object: any): QueryBuildAddressRequest;
+    toJSON(message: QueryBuildAddressRequest): JsonSafe<QueryBuildAddressRequest>;
+    fromPartial<I extends Exact<DeepPartial<QueryBuildAddressRequest>, I>>(object: I): QueryBuildAddressRequest;
+    fromAmino(object: QueryBuildAddressRequestAmino): QueryBuildAddressRequest;
+    toAmino(message: QueryBuildAddressRequest): QueryBuildAddressRequestAmino;
+    fromAminoMsg(object: QueryBuildAddressRequestAminoMsg): QueryBuildAddressRequest;
+    toAminoMsg(message: QueryBuildAddressRequest): QueryBuildAddressRequestAminoMsg;
+    fromProtoMsg(message: QueryBuildAddressRequestProtoMsg): QueryBuildAddressRequest;
+    toProto(message: QueryBuildAddressRequest): Uint8Array;
+    toProtoMsg(message: QueryBuildAddressRequest): QueryBuildAddressRequestProtoMsg;
+};
+export declare const QueryBuildAddressResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryBuildAddressResponse;
+    isSDK(o: any): o is QueryBuildAddressResponseSDKType;
+    isAmino(o: any): o is QueryBuildAddressResponseAmino;
+    encode(message: QueryBuildAddressResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryBuildAddressResponse;
+    fromJSON(object: any): QueryBuildAddressResponse;
+    toJSON(message: QueryBuildAddressResponse): JsonSafe<QueryBuildAddressResponse>;
+    fromPartial<I extends Exact<DeepPartial<QueryBuildAddressResponse>, I>>(object: I): QueryBuildAddressResponse;
+    fromAmino(object: QueryBuildAddressResponseAmino): QueryBuildAddressResponse;
+    toAmino(message: QueryBuildAddressResponse): QueryBuildAddressResponseAmino;
+    fromAminoMsg(object: QueryBuildAddressResponseAminoMsg): QueryBuildAddressResponse;
+    toAminoMsg(message: QueryBuildAddressResponse): QueryBuildAddressResponseAminoMsg;
+    fromProtoMsg(message: QueryBuildAddressResponseProtoMsg): QueryBuildAddressResponse;
+    toProto(message: QueryBuildAddressResponse): Uint8Array;
+    toProtoMsg(message: QueryBuildAddressResponse): QueryBuildAddressResponseProtoMsg;
+};