import { PageRequest, PageRequestAmino, PageResponse, PageResponseAmino } from "../../../cosmos/base/query/v1beta1/pagination";
import { ContractInfo, ContractInfoAmino, ContractCodeHistoryEntry, ContractCodeHistoryEntryAmino, Model, ModelAmino, AccessConfig, AccessConfigAmino, Params, ParamsAmino } from "./types";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { DeepPartial } from "../../../helpers";
/**
 * QueryContractInfoRequest is the request type for the Query/ContractInfo RPC
 * method
 * @name QueryContractInfoRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractInfoRequest
 */
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
 * @name QueryContractInfoRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractInfoRequest
 */
export interface QueryContractInfoRequestAmino {
    /**
     * address is the address of the contract to query
     */
    address: string;
}
export interface QueryContractInfoRequestAminoMsg {
    type: "wasm/QueryContractInfoRequest";
    value: QueryContractInfoRequestAmino;
}
/**
 * QueryContractInfoResponse is the response type for the Query/ContractInfo RPC
 * method
 * @name QueryContractInfoResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractInfoResponse
 */
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
 * @name QueryContractInfoResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractInfoResponse
 */
export interface QueryContractInfoResponseAmino {
    /**
     * address is the address of the contract
     */
    address: string;
    contract_info: ContractInfoAmino;
}
export interface QueryContractInfoResponseAminoMsg {
    type: "wasm/QueryContractInfoResponse";
    value: QueryContractInfoResponseAmino;
}
/**
 * QueryContractHistoryRequest is the request type for the Query/ContractHistory
 * RPC method
 * @name QueryContractHistoryRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractHistoryRequest
 */
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
 * @name QueryContractHistoryRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractHistoryRequest
 */
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;
}
/**
 * QueryContractHistoryResponse is the response type for the
 * Query/ContractHistory RPC method
 * @name QueryContractHistoryResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractHistoryResponse
 */
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
 * @name QueryContractHistoryResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractHistoryResponse
 */
export interface QueryContractHistoryResponseAmino {
    entries: ContractCodeHistoryEntryAmino[];
    /**
     * pagination defines the pagination in the response.
     */
    pagination?: PageResponseAmino;
}
export interface QueryContractHistoryResponseAminoMsg {
    type: "wasm/QueryContractHistoryResponse";
    value: QueryContractHistoryResponseAmino;
}
/**
 * QueryContractsByCodeRequest is the request type for the Query/ContractsByCode
 * RPC method
 * @name QueryContractsByCodeRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCodeRequest
 */
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
 * @name QueryContractsByCodeRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCodeRequest
 */
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;
}
/**
 * QueryContractsByCodeResponse is the response type for the
 * Query/ContractsByCode RPC method
 * @name QueryContractsByCodeResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCodeResponse
 */
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
 * @name QueryContractsByCodeResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCodeResponse
 */
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;
}
/**
 * QueryAllContractStateRequest is the request type for the
 * Query/AllContractState RPC method
 * @name QueryAllContractStateRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryAllContractStateRequest
 */
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
 * @name QueryAllContractStateRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryAllContractStateRequest
 */
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;
}
/**
 * QueryAllContractStateResponse is the response type for the
 * Query/AllContractState RPC method
 * @name QueryAllContractStateResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryAllContractStateResponse
 */
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
 * @name QueryAllContractStateResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryAllContractStateResponse
 */
export interface QueryAllContractStateResponseAmino {
    models: ModelAmino[];
    /**
     * pagination defines the pagination in the response.
     */
    pagination?: PageResponseAmino;
}
export interface QueryAllContractStateResponseAminoMsg {
    type: "wasm/QueryAllContractStateResponse";
    value: QueryAllContractStateResponseAmino;
}
/**
 * QueryRawContractStateRequest is the request type for the
 * Query/RawContractState RPC method
 * @name QueryRawContractStateRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryRawContractStateRequest
 */
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
 * @name QueryRawContractStateRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryRawContractStateRequest
 */
export interface QueryRawContractStateRequestAmino {
    /**
     * address is the address of the contract
     */
    address: string;
    query_data: string;
}
export interface QueryRawContractStateRequestAminoMsg {
    type: "wasm/QueryRawContractStateRequest";
    value: QueryRawContractStateRequestAmino;
}
/**
 * QueryRawContractStateResponse is the response type for the
 * Query/RawContractState RPC method
 * @name QueryRawContractStateResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryRawContractStateResponse
 */
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
 * @name QueryRawContractStateResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryRawContractStateResponse
 */
export interface QueryRawContractStateResponseAmino {
    /**
     * Data contains the raw store data
     */
    data: string;
}
export interface QueryRawContractStateResponseAminoMsg {
    type: "wasm/QueryRawContractStateResponse";
    value: QueryRawContractStateResponseAmino;
}
/**
 * QuerySmartContractStateRequest is the request type for the
 * Query/SmartContractState RPC method
 * @name QuerySmartContractStateRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QuerySmartContractStateRequest
 */
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
 * @name QuerySmartContractStateRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QuerySmartContractStateRequest
 */
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;
}
/**
 * QuerySmartContractStateResponse is the response type for the
 * Query/SmartContractState RPC method
 * @name QuerySmartContractStateResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QuerySmartContractStateResponse
 */
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
 * @name QuerySmartContractStateResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QuerySmartContractStateResponse
 */
export interface QuerySmartContractStateResponseAmino {
    /**
     * Data contains the json data returned from the smart contract
     */
    data: any;
}
export interface QuerySmartContractStateResponseAminoMsg {
    type: "wasm/QuerySmartContractStateResponse";
    value: QuerySmartContractStateResponseAmino;
}
/**
 * QueryCodeRequest is the request type for the Query/Code RPC method
 * @name QueryCodeRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeRequest
 */
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
 * @name QueryCodeRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeRequest
 */
export interface QueryCodeRequestAmino {
    /**
     * grpc-gateway_out does not support Go style CodeID
     */
    code_id: string;
}
export interface QueryCodeRequestAminoMsg {
    type: "wasm/QueryCodeRequest";
    value: QueryCodeRequestAmino;
}
/**
 * QueryCodeInfoRequest is the request type for the Query/CodeInfo RPC method
 * @name QueryCodeInfoRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeInfoRequest
 */
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
 * @name QueryCodeInfoRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeInfoRequest
 */
export interface QueryCodeInfoRequestAmino {
    /**
     * grpc-gateway_out does not support Go style CodeID
     */
    code_id: string;
}
export interface QueryCodeInfoRequestAminoMsg {
    type: "wasm/QueryCodeInfoRequest";
    value: QueryCodeInfoRequestAmino;
}
/**
 * QueryCodeInfoResponse is the response type for the Query/CodeInfo RPC method
 * @name QueryCodeInfoResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeInfoResponse
 */
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
 * @name QueryCodeInfoResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeInfoResponse
 */
export interface QueryCodeInfoResponseAmino {
    code_id: string;
    creator: string;
    checksum: string;
    instantiate_permission: AccessConfigAmino;
}
export interface QueryCodeInfoResponseAminoMsg {
    type: "wasm/QueryCodeInfoResponse";
    value: QueryCodeInfoResponseAmino;
}
/**
 * CodeInfoResponse contains code meta data from CodeInfo
 * @name CodeInfoResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.CodeInfoResponse
 */
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
 * @name CodeInfoResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.CodeInfoResponse
 */
export interface CodeInfoResponseAmino {
    code_id: string;
    creator: string;
    data_hash: string;
    instantiate_permission: AccessConfigAmino;
}
export interface CodeInfoResponseAminoMsg {
    type: "wasm/CodeInfoResponse";
    value: CodeInfoResponseAmino;
}
/**
 * QueryCodeResponse is the response type for the Query/Code RPC method
 * @name QueryCodeResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeResponse
 */
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
 * @name QueryCodeResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeResponse
 */
export interface QueryCodeResponseAmino {
    code_info?: CodeInfoResponseAmino;
    data: string;
}
export interface QueryCodeResponseAminoMsg {
    type: "wasm/QueryCodeResponse";
    value: QueryCodeResponseAmino;
}
/**
 * QueryCodesRequest is the request type for the Query/Codes RPC method
 * @name QueryCodesRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodesRequest
 */
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
 * @name QueryCodesRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodesRequest
 */
export interface QueryCodesRequestAmino {
    /**
     * pagination defines an optional pagination for the request.
     */
    pagination?: PageRequestAmino;
}
export interface QueryCodesRequestAminoMsg {
    type: "wasm/QueryCodesRequest";
    value: QueryCodesRequestAmino;
}
/**
 * QueryCodesResponse is the response type for the Query/Codes RPC method
 * @name QueryCodesResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodesResponse
 */
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
 * @name QueryCodesResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodesResponse
 */
export interface QueryCodesResponseAmino {
    code_infos: CodeInfoResponseAmino[];
    /**
     * pagination defines the pagination in the response.
     */
    pagination?: PageResponseAmino;
}
export interface QueryCodesResponseAminoMsg {
    type: "wasm/QueryCodesResponse";
    value: QueryCodesResponseAmino;
}
/**
 * QueryPinnedCodesRequest is the request type for the Query/PinnedCodes
 * RPC method
 * @name QueryPinnedCodesRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryPinnedCodesRequest
 */
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
 * @name QueryPinnedCodesRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryPinnedCodesRequest
 */
export interface QueryPinnedCodesRequestAmino {
    /**
     * pagination defines an optional pagination for the request.
     */
    pagination?: PageRequestAmino;
}
export interface QueryPinnedCodesRequestAminoMsg {
    type: "wasm/QueryPinnedCodesRequest";
    value: QueryPinnedCodesRequestAmino;
}
/**
 * QueryPinnedCodesResponse is the response type for the
 * Query/PinnedCodes RPC method
 * @name QueryPinnedCodesResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryPinnedCodesResponse
 */
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
 * @name QueryPinnedCodesResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryPinnedCodesResponse
 */
export interface QueryPinnedCodesResponseAmino {
    code_ids: string[];
    /**
     * pagination defines the pagination in the response.
     */
    pagination?: PageResponseAmino;
}
export interface QueryPinnedCodesResponseAminoMsg {
    type: "wasm/QueryPinnedCodesResponse";
    value: QueryPinnedCodesResponseAmino;
}
/**
 * QueryParamsRequest is the request type for the Query/Params RPC method.
 * @name QueryParamsRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryParamsRequest
 */
export interface QueryParamsRequest {
}
export interface QueryParamsRequestProtoMsg {
    typeUrl: "/cosmwasm.wasm.v1.QueryParamsRequest";
    value: Uint8Array;
}
/**
 * QueryParamsRequest is the request type for the Query/Params RPC method.
 * @name QueryParamsRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryParamsRequest
 */
export interface QueryParamsRequestAmino {
}
export interface QueryParamsRequestAminoMsg {
    type: "wasm/QueryParamsRequest";
    value: QueryParamsRequestAmino;
}
/**
 * QueryParamsResponse is the response type for the Query/Params RPC method.
 * @name QueryParamsResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryParamsResponse
 */
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.
 * @name QueryParamsResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryParamsResponse
 */
export interface QueryParamsResponseAmino {
    /**
     * params defines the parameters of the module.
     */
    params: ParamsAmino;
}
export interface QueryParamsResponseAminoMsg {
    type: "wasm/QueryParamsResponse";
    value: QueryParamsResponseAmino;
}
/**
 * QueryContractsByCreatorRequest is the request type for the
 * Query/ContractsByCreator RPC method.
 * @name QueryContractsByCreatorRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCreatorRequest
 */
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.
 * @name QueryContractsByCreatorRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCreatorRequest
 */
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;
}
/**
 * QueryContractsByCreatorResponse is the response type for the
 * Query/ContractsByCreator RPC method.
 * @name QueryContractsByCreatorResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCreatorResponse
 */
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.
 * @name QueryContractsByCreatorResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCreatorResponse
 */
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;
}
/**
 * QueryWasmLimitsConfigRequest is the request type for the
 * Query/WasmLimitsConfig RPC method.
 * @name QueryWasmLimitsConfigRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryWasmLimitsConfigRequest
 */
export interface QueryWasmLimitsConfigRequest {
}
export interface QueryWasmLimitsConfigRequestProtoMsg {
    typeUrl: "/cosmwasm.wasm.v1.QueryWasmLimitsConfigRequest";
    value: Uint8Array;
}
/**
 * QueryWasmLimitsConfigRequest is the request type for the
 * Query/WasmLimitsConfig RPC method.
 * @name QueryWasmLimitsConfigRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryWasmLimitsConfigRequest
 */
export interface QueryWasmLimitsConfigRequestAmino {
}
export interface QueryWasmLimitsConfigRequestAminoMsg {
    type: "wasm/QueryWasmLimitsConfigRequest";
    value: QueryWasmLimitsConfigRequestAmino;
}
/**
 * QueryWasmLimitsConfigResponse is the response type for the
 * Query/WasmLimitsConfig RPC method. It contains the JSON encoded limits for
 * static validation of Wasm files.
 * @name QueryWasmLimitsConfigResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryWasmLimitsConfigResponse
 */
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.
 * @name QueryWasmLimitsConfigResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryWasmLimitsConfigResponse
 */
export interface QueryWasmLimitsConfigResponseAmino {
    config: string;
}
export interface QueryWasmLimitsConfigResponseAminoMsg {
    type: "wasm/QueryWasmLimitsConfigResponse";
    value: QueryWasmLimitsConfigResponseAmino;
}
/**
 * QueryBuildAddressRequest is the request type for the Query/BuildAddress RPC
 * method.
 * @name QueryBuildAddressRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryBuildAddressRequest
 */
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.
 * @name QueryBuildAddressRequestAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryBuildAddressRequest
 */
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;
}
/**
 * QueryBuildAddressResponse is the response type for the Query/BuildAddress RPC
 * method.
 * @name QueryBuildAddressResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryBuildAddressResponse
 */
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.
 * @name QueryBuildAddressResponseAmino
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryBuildAddressResponse
 */
export interface QueryBuildAddressResponseAmino {
    /**
     * Address is the contract address
     */
    address: string;
}
export interface QueryBuildAddressResponseAminoMsg {
    type: "wasm/QueryBuildAddressResponse";
    value: QueryBuildAddressResponseAmino;
}
/**
 * QueryContractInfoRequest is the request type for the Query/ContractInfo RPC
 * method
 * @name QueryContractInfoRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractInfoRequest
 */
export declare const QueryContractInfoRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryContractInfoRequest;
    isAmino(o: any): o is QueryContractInfoRequestAmino;
    encode(message: QueryContractInfoRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractInfoRequest;
    fromPartial(object: DeepPartial<QueryContractInfoRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryContractInfoResponse is the response type for the Query/ContractInfo RPC
 * method
 * @name QueryContractInfoResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractInfoResponse
 */
export declare const QueryContractInfoResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryContractInfoResponse;
    isAmino(o: any): o is QueryContractInfoResponseAmino;
    encode(message: QueryContractInfoResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractInfoResponse;
    fromPartial(object: DeepPartial<QueryContractInfoResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryContractHistoryRequest is the request type for the Query/ContractHistory
 * RPC method
 * @name QueryContractHistoryRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractHistoryRequest
 */
export declare const QueryContractHistoryRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryContractHistoryRequest;
    isAmino(o: any): o is QueryContractHistoryRequestAmino;
    encode(message: QueryContractHistoryRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractHistoryRequest;
    fromPartial(object: DeepPartial<QueryContractHistoryRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryContractHistoryResponse is the response type for the
 * Query/ContractHistory RPC method
 * @name QueryContractHistoryResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractHistoryResponse
 */
export declare const QueryContractHistoryResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryContractHistoryResponse;
    isAmino(o: any): o is QueryContractHistoryResponseAmino;
    encode(message: QueryContractHistoryResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractHistoryResponse;
    fromPartial(object: DeepPartial<QueryContractHistoryResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryContractsByCodeRequest is the request type for the Query/ContractsByCode
 * RPC method
 * @name QueryContractsByCodeRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCodeRequest
 */
export declare const QueryContractsByCodeRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryContractsByCodeRequest;
    isAmino(o: any): o is QueryContractsByCodeRequestAmino;
    encode(message: QueryContractsByCodeRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractsByCodeRequest;
    fromPartial(object: DeepPartial<QueryContractsByCodeRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryContractsByCodeResponse is the response type for the
 * Query/ContractsByCode RPC method
 * @name QueryContractsByCodeResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCodeResponse
 */
export declare const QueryContractsByCodeResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryContractsByCodeResponse;
    isAmino(o: any): o is QueryContractsByCodeResponseAmino;
    encode(message: QueryContractsByCodeResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractsByCodeResponse;
    fromPartial(object: DeepPartial<QueryContractsByCodeResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryAllContractStateRequest is the request type for the
 * Query/AllContractState RPC method
 * @name QueryAllContractStateRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryAllContractStateRequest
 */
export declare const QueryAllContractStateRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryAllContractStateRequest;
    isAmino(o: any): o is QueryAllContractStateRequestAmino;
    encode(message: QueryAllContractStateRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryAllContractStateRequest;
    fromPartial(object: DeepPartial<QueryAllContractStateRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryAllContractStateResponse is the response type for the
 * Query/AllContractState RPC method
 * @name QueryAllContractStateResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryAllContractStateResponse
 */
export declare const QueryAllContractStateResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryAllContractStateResponse;
    isAmino(o: any): o is QueryAllContractStateResponseAmino;
    encode(message: QueryAllContractStateResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryAllContractStateResponse;
    fromPartial(object: DeepPartial<QueryAllContractStateResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryRawContractStateRequest is the request type for the
 * Query/RawContractState RPC method
 * @name QueryRawContractStateRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryRawContractStateRequest
 */
export declare const QueryRawContractStateRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryRawContractStateRequest;
    isAmino(o: any): o is QueryRawContractStateRequestAmino;
    encode(message: QueryRawContractStateRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryRawContractStateRequest;
    fromPartial(object: DeepPartial<QueryRawContractStateRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryRawContractStateResponse is the response type for the
 * Query/RawContractState RPC method
 * @name QueryRawContractStateResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryRawContractStateResponse
 */
export declare const QueryRawContractStateResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryRawContractStateResponse;
    isAmino(o: any): o is QueryRawContractStateResponseAmino;
    encode(message: QueryRawContractStateResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryRawContractStateResponse;
    fromPartial(object: DeepPartial<QueryRawContractStateResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QuerySmartContractStateRequest is the request type for the
 * Query/SmartContractState RPC method
 * @name QuerySmartContractStateRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QuerySmartContractStateRequest
 */
export declare const QuerySmartContractStateRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QuerySmartContractStateRequest;
    isAmino(o: any): o is QuerySmartContractStateRequestAmino;
    encode(message: QuerySmartContractStateRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QuerySmartContractStateRequest;
    fromPartial(object: DeepPartial<QuerySmartContractStateRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QuerySmartContractStateResponse is the response type for the
 * Query/SmartContractState RPC method
 * @name QuerySmartContractStateResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QuerySmartContractStateResponse
 */
export declare const QuerySmartContractStateResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QuerySmartContractStateResponse;
    isAmino(o: any): o is QuerySmartContractStateResponseAmino;
    encode(message: QuerySmartContractStateResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QuerySmartContractStateResponse;
    fromPartial(object: DeepPartial<QuerySmartContractStateResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryCodeRequest is the request type for the Query/Code RPC method
 * @name QueryCodeRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeRequest
 */
export declare const QueryCodeRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryCodeRequest;
    isAmino(o: any): o is QueryCodeRequestAmino;
    encode(message: QueryCodeRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodeRequest;
    fromPartial(object: DeepPartial<QueryCodeRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryCodeInfoRequest is the request type for the Query/CodeInfo RPC method
 * @name QueryCodeInfoRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeInfoRequest
 */
export declare const QueryCodeInfoRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryCodeInfoRequest;
    isAmino(o: any): o is QueryCodeInfoRequestAmino;
    encode(message: QueryCodeInfoRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodeInfoRequest;
    fromPartial(object: DeepPartial<QueryCodeInfoRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryCodeInfoResponse is the response type for the Query/CodeInfo RPC method
 * @name QueryCodeInfoResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeInfoResponse
 */
export declare const QueryCodeInfoResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryCodeInfoResponse;
    isAmino(o: any): o is QueryCodeInfoResponseAmino;
    encode(message: QueryCodeInfoResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodeInfoResponse;
    fromPartial(object: DeepPartial<QueryCodeInfoResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * CodeInfoResponse contains code meta data from CodeInfo
 * @name CodeInfoResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.CodeInfoResponse
 */
export declare const CodeInfoResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is CodeInfoResponse;
    isAmino(o: any): o is CodeInfoResponseAmino;
    encode(message: CodeInfoResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): CodeInfoResponse;
    fromPartial(object: DeepPartial<CodeInfoResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryCodeResponse is the response type for the Query/Code RPC method
 * @name QueryCodeResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodeResponse
 */
export declare const QueryCodeResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryCodeResponse;
    isAmino(o: any): o is QueryCodeResponseAmino;
    encode(message: QueryCodeResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodeResponse;
    fromPartial(object: DeepPartial<QueryCodeResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryCodesRequest is the request type for the Query/Codes RPC method
 * @name QueryCodesRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodesRequest
 */
export declare const QueryCodesRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryCodesRequest;
    isAmino(o: any): o is QueryCodesRequestAmino;
    encode(message: QueryCodesRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodesRequest;
    fromPartial(object: DeepPartial<QueryCodesRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryCodesResponse is the response type for the Query/Codes RPC method
 * @name QueryCodesResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryCodesResponse
 */
export declare const QueryCodesResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryCodesResponse;
    isAmino(o: any): o is QueryCodesResponseAmino;
    encode(message: QueryCodesResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodesResponse;
    fromPartial(object: DeepPartial<QueryCodesResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryPinnedCodesRequest is the request type for the Query/PinnedCodes
 * RPC method
 * @name QueryPinnedCodesRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryPinnedCodesRequest
 */
export declare const QueryPinnedCodesRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryPinnedCodesRequest;
    isAmino(o: any): o is QueryPinnedCodesRequestAmino;
    encode(message: QueryPinnedCodesRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryPinnedCodesRequest;
    fromPartial(object: DeepPartial<QueryPinnedCodesRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryPinnedCodesResponse is the response type for the
 * Query/PinnedCodes RPC method
 * @name QueryPinnedCodesResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryPinnedCodesResponse
 */
export declare const QueryPinnedCodesResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryPinnedCodesResponse;
    isAmino(o: any): o is QueryPinnedCodesResponseAmino;
    encode(message: QueryPinnedCodesResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryPinnedCodesResponse;
    fromPartial(object: DeepPartial<QueryPinnedCodesResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryParamsRequest is the request type for the Query/Params RPC method.
 * @name QueryParamsRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryParamsRequest
 */
export declare const QueryParamsRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryParamsRequest;
    isAmino(o: any): o is QueryParamsRequestAmino;
    encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest;
    fromPartial(_: DeepPartial<QueryParamsRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryParamsResponse is the response type for the Query/Params RPC method.
 * @name QueryParamsResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryParamsResponse
 */
export declare const QueryParamsResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryParamsResponse;
    isAmino(o: any): o is QueryParamsResponseAmino;
    encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse;
    fromPartial(object: DeepPartial<QueryParamsResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryContractsByCreatorRequest is the request type for the
 * Query/ContractsByCreator RPC method.
 * @name QueryContractsByCreatorRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCreatorRequest
 */
export declare const QueryContractsByCreatorRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryContractsByCreatorRequest;
    isAmino(o: any): o is QueryContractsByCreatorRequestAmino;
    encode(message: QueryContractsByCreatorRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractsByCreatorRequest;
    fromPartial(object: DeepPartial<QueryContractsByCreatorRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryContractsByCreatorResponse is the response type for the
 * Query/ContractsByCreator RPC method.
 * @name QueryContractsByCreatorResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryContractsByCreatorResponse
 */
export declare const QueryContractsByCreatorResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryContractsByCreatorResponse;
    isAmino(o: any): o is QueryContractsByCreatorResponseAmino;
    encode(message: QueryContractsByCreatorResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractsByCreatorResponse;
    fromPartial(object: DeepPartial<QueryContractsByCreatorResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryWasmLimitsConfigRequest is the request type for the
 * Query/WasmLimitsConfig RPC method.
 * @name QueryWasmLimitsConfigRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryWasmLimitsConfigRequest
 */
export declare const QueryWasmLimitsConfigRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryWasmLimitsConfigRequest;
    isAmino(o: any): o is QueryWasmLimitsConfigRequestAmino;
    encode(_: QueryWasmLimitsConfigRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryWasmLimitsConfigRequest;
    fromPartial(_: DeepPartial<QueryWasmLimitsConfigRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryWasmLimitsConfigResponse is the response type for the
 * Query/WasmLimitsConfig RPC method. It contains the JSON encoded limits for
 * static validation of Wasm files.
 * @name QueryWasmLimitsConfigResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryWasmLimitsConfigResponse
 */
export declare const QueryWasmLimitsConfigResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryWasmLimitsConfigResponse;
    isAmino(o: any): o is QueryWasmLimitsConfigResponseAmino;
    encode(message: QueryWasmLimitsConfigResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryWasmLimitsConfigResponse;
    fromPartial(object: DeepPartial<QueryWasmLimitsConfigResponse>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryBuildAddressRequest is the request type for the Query/BuildAddress RPC
 * method.
 * @name QueryBuildAddressRequest
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryBuildAddressRequest
 */
export declare const QueryBuildAddressRequest: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryBuildAddressRequest;
    isAmino(o: any): o is QueryBuildAddressRequestAmino;
    encode(message: QueryBuildAddressRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryBuildAddressRequest;
    fromPartial(object: DeepPartial<QueryBuildAddressRequest>): 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;
    registerTypeUrl(): void;
};
/**
 * QueryBuildAddressResponse is the response type for the Query/BuildAddress RPC
 * method.
 * @name QueryBuildAddressResponse
 * @package cosmwasm.wasm.v1
 * @see proto type: cosmwasm.wasm.v1.QueryBuildAddressResponse
 */
export declare const QueryBuildAddressResponse: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is QueryBuildAddressResponse;
    isAmino(o: any): o is QueryBuildAddressResponseAmino;
    encode(message: QueryBuildAddressResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QueryBuildAddressResponse;
    fromPartial(object: DeepPartial<QueryBuildAddressResponse>): 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;
    registerTypeUrl(): void;
};