juno-network 0.7.0 → 0.8.0

package/types/codegen/ibc/core/connection/v1/connection.d.ts

@@ -0,0 +1,260 @@
+import { MerklePrefix, MerklePrefixSDKType } from "../../commitment/v1/commitment";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "../../../../helpers";
+/**
+ * State defines if a connection is in one of the following states:
+ * INIT, TRYOPEN, OPEN or UNINITIALIZED.
+ */
+export declare enum State {
+    /** STATE_UNINITIALIZED_UNSPECIFIED - Default State */
+    STATE_UNINITIALIZED_UNSPECIFIED = 0,
+    /** STATE_INIT - A connection end has just started the opening handshake. */
+    STATE_INIT = 1,
+    /**
+     * STATE_TRYOPEN - A connection end has acknowledged the handshake step on the counterparty
+     * chain.
+     */
+    STATE_TRYOPEN = 2,
+    /** STATE_OPEN - A connection end has completed the handshake. */
+    STATE_OPEN = 3,
+    UNRECOGNIZED = -1
+}
+/**
+ * State defines if a connection is in one of the following states:
+ * INIT, TRYOPEN, OPEN or UNINITIALIZED.
+ */
+export declare enum StateSDKType {
+    /** STATE_UNINITIALIZED_UNSPECIFIED - Default State */
+    STATE_UNINITIALIZED_UNSPECIFIED = 0,
+    /** STATE_INIT - A connection end has just started the opening handshake. */
+    STATE_INIT = 1,
+    /**
+     * STATE_TRYOPEN - A connection end has acknowledged the handshake step on the counterparty
+     * chain.
+     */
+    STATE_TRYOPEN = 2,
+    /** STATE_OPEN - A connection end has completed the handshake. */
+    STATE_OPEN = 3,
+    UNRECOGNIZED = -1
+}
+export declare function stateFromJSON(object: any): State;
+export declare function stateToJSON(object: State): string;
+/**
+ * ConnectionEnd defines a stateful object on a chain connected to another
+ * separate one.
+ * NOTE: there must only be 2 defined ConnectionEnds to establish
+ * a connection between two chains.
+ */
+export interface ConnectionEnd {
+    /** client associated with this connection. */
+    clientId: string;
+    /**
+     * IBC version which can be utilised to determine encodings or protocols for
+     * channels or packets utilising this connection.
+     */
+    versions: Version[];
+    /** current state of the connection end. */
+    state: State;
+    /** counterparty chain associated with this connection. */
+    counterparty?: Counterparty;
+    /**
+     * delay period that must pass before a consensus state can be used for
+     * packet-verification NOTE: delay period logic is only implemented by some
+     * clients.
+     */
+    delayPeriod: Long;
+}
+/**
+ * ConnectionEnd defines a stateful object on a chain connected to another
+ * separate one.
+ * NOTE: there must only be 2 defined ConnectionEnds to establish
+ * a connection between two chains.
+ */
+export interface ConnectionEndSDKType {
+    /** client associated with this connection. */
+    client_id: string;
+    /**
+     * IBC version which can be utilised to determine encodings or protocols for
+     * channels or packets utilising this connection.
+     */
+    versions: VersionSDKType[];
+    /** current state of the connection end. */
+    state: StateSDKType;
+    /** counterparty chain associated with this connection. */
+    counterparty?: CounterpartySDKType;
+    /**
+     * delay period that must pass before a consensus state can be used for
+     * packet-verification NOTE: delay period logic is only implemented by some
+     * clients.
+     */
+    delay_period: Long;
+}
+/**
+ * IdentifiedConnection defines a connection with additional connection
+ * identifier field.
+ */
+export interface IdentifiedConnection {
+    /** connection identifier. */
+    id: string;
+    /** client associated with this connection. */
+    clientId: string;
+    /**
+     * IBC version which can be utilised to determine encodings or protocols for
+     * channels or packets utilising this connection
+     */
+    versions: Version[];
+    /** current state of the connection end. */
+    state: State;
+    /** counterparty chain associated with this connection. */
+    counterparty?: Counterparty;
+    /** delay period associated with this connection. */
+    delayPeriod: Long;
+}
+/**
+ * IdentifiedConnection defines a connection with additional connection
+ * identifier field.
+ */
+export interface IdentifiedConnectionSDKType {
+    /** connection identifier. */
+    id: string;
+    /** client associated with this connection. */
+    client_id: string;
+    /**
+     * IBC version which can be utilised to determine encodings or protocols for
+     * channels or packets utilising this connection
+     */
+    versions: VersionSDKType[];
+    /** current state of the connection end. */
+    state: StateSDKType;
+    /** counterparty chain associated with this connection. */
+    counterparty?: CounterpartySDKType;
+    /** delay period associated with this connection. */
+    delay_period: Long;
+}
+/** Counterparty defines the counterparty chain associated with a connection end. */
+export interface Counterparty {
+    /**
+     * identifies the client on the counterparty chain associated with a given
+     * connection.
+     */
+    clientId: string;
+    /**
+     * identifies the connection end on the counterparty chain associated with a
+     * given connection.
+     */
+    connectionId: string;
+    /** commitment merkle prefix of the counterparty chain. */
+    prefix?: MerklePrefix;
+}
+/** Counterparty defines the counterparty chain associated with a connection end. */
+export interface CounterpartySDKType {
+    /**
+     * identifies the client on the counterparty chain associated with a given
+     * connection.
+     */
+    client_id: string;
+    /**
+     * identifies the connection end on the counterparty chain associated with a
+     * given connection.
+     */
+    connection_id: string;
+    /** commitment merkle prefix of the counterparty chain. */
+    prefix?: MerklePrefixSDKType;
+}
+/** ClientPaths define all the connection paths for a client state. */
+export interface ClientPaths {
+    /** list of connection paths */
+    paths: string[];
+}
+/** ClientPaths define all the connection paths for a client state. */
+export interface ClientPathsSDKType {
+    /** list of connection paths */
+    paths: string[];
+}
+/** ConnectionPaths define all the connection paths for a given client state. */
+export interface ConnectionPaths {
+    /** client state unique identifier */
+    clientId: string;
+    /** list of connection paths */
+    paths: string[];
+}
+/** ConnectionPaths define all the connection paths for a given client state. */
+export interface ConnectionPathsSDKType {
+    /** client state unique identifier */
+    client_id: string;
+    /** list of connection paths */
+    paths: string[];
+}
+/**
+ * Version defines the versioning scheme used to negotiate the IBC verison in
+ * the connection handshake.
+ */
+export interface Version {
+    /** unique version identifier */
+    identifier: string;
+    /** list of features compatible with the specified identifier */
+    features: string[];
+}
+/**
+ * Version defines the versioning scheme used to negotiate the IBC verison in
+ * the connection handshake.
+ */
+export interface VersionSDKType {
+    /** unique version identifier */
+    identifier: string;
+    /** list of features compatible with the specified identifier */
+    features: string[];
+}
+/** Params defines the set of Connection parameters. */
+export interface Params {
+    /**
+     * maximum expected time per block (in nanoseconds), used to enforce block delay. This parameter should reflect the
+     * largest amount of time that the chain might reasonably take to produce the next block under normal operating
+     * conditions. A safe choice is 3-5x the expected time per block.
+     */
+    maxExpectedTimePerBlock: Long;
+}
+/** Params defines the set of Connection parameters. */
+export interface ParamsSDKType {
+    /**
+     * maximum expected time per block (in nanoseconds), used to enforce block delay. This parameter should reflect the
+     * largest amount of time that the chain might reasonably take to produce the next block under normal operating
+     * conditions. A safe choice is 3-5x the expected time per block.
+     */
+    max_expected_time_per_block: Long;
+}
+export declare const ConnectionEnd: {
+    encode(message: ConnectionEnd, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ConnectionEnd;
+    fromPartial(object: DeepPartial<ConnectionEnd>): ConnectionEnd;
+};
+export declare const IdentifiedConnection: {
+    encode(message: IdentifiedConnection, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): IdentifiedConnection;
+    fromPartial(object: DeepPartial<IdentifiedConnection>): IdentifiedConnection;
+};
+export declare const Counterparty: {
+    encode(message: Counterparty, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Counterparty;
+    fromPartial(object: DeepPartial<Counterparty>): Counterparty;
+};
+export declare const ClientPaths: {
+    encode(message: ClientPaths, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ClientPaths;
+    fromPartial(object: DeepPartial<ClientPaths>): ClientPaths;
+};
+export declare const ConnectionPaths: {
+    encode(message: ConnectionPaths, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ConnectionPaths;
+    fromPartial(object: DeepPartial<ConnectionPaths>): ConnectionPaths;
+};
+export declare const Version: {
+    encode(message: Version, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Version;
+    fromPartial(object: DeepPartial<Version>): Version;
+};
+export declare const Params: {
+    encode(message: Params, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Params;
+    fromPartial(object: DeepPartial<Params>): Params;
+};

package/types/codegen/ibc/core/connection/v1/genesis.d.ts

@@ -0,0 +1,24 @@
+import { IdentifiedConnection, IdentifiedConnectionSDKType, ConnectionPaths, ConnectionPathsSDKType, Params, ParamsSDKType } from "./connection";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "../../../../helpers";
+/** GenesisState defines the ibc connection submodule's genesis state. */
+export interface GenesisState {
+    connections: IdentifiedConnection[];
+    clientConnectionPaths: ConnectionPaths[];
+    /** the sequence for the next generated connection identifier */
+    nextConnectionSequence: Long;
+    params?: Params;
+}
+/** GenesisState defines the ibc connection submodule's genesis state. */
+export interface GenesisStateSDKType {
+    connections: IdentifiedConnectionSDKType[];
+    client_connection_paths: ConnectionPathsSDKType[];
+    /** the sequence for the next generated connection identifier */
+    next_connection_sequence: Long;
+    params?: ParamsSDKType;
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+};

package/types/codegen/ibc/core/connection/v1/query.d.ts

@@ -0,0 +1,264 @@
+import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../../../cosmos/base/query/v1beta1/pagination";
+import { ConnectionEnd, ConnectionEndSDKType, IdentifiedConnection, IdentifiedConnectionSDKType } from "./connection";
+import { Height, HeightSDKType, IdentifiedClientState, IdentifiedClientStateSDKType } from "../../client/v1/client";
+import { Any, AnySDKType } from "../../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../../../helpers";
+/**
+ * QueryConnectionRequest is the request type for the Query/Connection RPC
+ * method
+ */
+export interface QueryConnectionRequest {
+    /** connection unique identifier */
+    connectionId: string;
+}
+/**
+ * QueryConnectionRequest is the request type for the Query/Connection RPC
+ * method
+ */
+export interface QueryConnectionRequestSDKType {
+    /** connection unique identifier */
+    connection_id: string;
+}
+/**
+ * QueryConnectionResponse is the response type for the Query/Connection RPC
+ * method. Besides the connection end, it includes a proof and the height from
+ * which the proof was retrieved.
+ */
+export interface QueryConnectionResponse {
+    /** connection associated with the request identifier */
+    connection?: ConnectionEnd;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proofHeight?: Height;
+}
+/**
+ * QueryConnectionResponse is the response type for the Query/Connection RPC
+ * method. Besides the connection end, it includes a proof and the height from
+ * which the proof was retrieved.
+ */
+export interface QueryConnectionResponseSDKType {
+    /** connection associated with the request identifier */
+    connection?: ConnectionEndSDKType;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proof_height?: HeightSDKType;
+}
+/**
+ * QueryConnectionsRequest is the request type for the Query/Connections RPC
+ * method
+ */
+export interface QueryConnectionsRequest {
+    pagination?: PageRequest;
+}
+/**
+ * QueryConnectionsRequest is the request type for the Query/Connections RPC
+ * method
+ */
+export interface QueryConnectionsRequestSDKType {
+    pagination?: PageRequestSDKType;
+}
+/**
+ * QueryConnectionsResponse is the response type for the Query/Connections RPC
+ * method.
+ */
+export interface QueryConnectionsResponse {
+    /** list of stored connections of the chain. */
+    connections: IdentifiedConnection[];
+    /** pagination response */
+    pagination?: PageResponse;
+    /** query block height */
+    height?: Height;
+}
+/**
+ * QueryConnectionsResponse is the response type for the Query/Connections RPC
+ * method.
+ */
+export interface QueryConnectionsResponseSDKType {
+    /** list of stored connections of the chain. */
+    connections: IdentifiedConnectionSDKType[];
+    /** pagination response */
+    pagination?: PageResponseSDKType;
+    /** query block height */
+    height?: HeightSDKType;
+}
+/**
+ * QueryClientConnectionsRequest is the request type for the
+ * Query/ClientConnections RPC method
+ */
+export interface QueryClientConnectionsRequest {
+    /** client identifier associated with a connection */
+    clientId: string;
+}
+/**
+ * QueryClientConnectionsRequest is the request type for the
+ * Query/ClientConnections RPC method
+ */
+export interface QueryClientConnectionsRequestSDKType {
+    /** client identifier associated with a connection */
+    client_id: string;
+}
+/**
+ * QueryClientConnectionsResponse is the response type for the
+ * Query/ClientConnections RPC method
+ */
+export interface QueryClientConnectionsResponse {
+    /** slice of all the connection paths associated with a client. */
+    connectionPaths: string[];
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was generated */
+    proofHeight?: Height;
+}
+/**
+ * QueryClientConnectionsResponse is the response type for the
+ * Query/ClientConnections RPC method
+ */
+export interface QueryClientConnectionsResponseSDKType {
+    /** slice of all the connection paths associated with a client. */
+    connection_paths: string[];
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was generated */
+    proof_height?: HeightSDKType;
+}
+/**
+ * QueryConnectionClientStateRequest is the request type for the
+ * Query/ConnectionClientState RPC method
+ */
+export interface QueryConnectionClientStateRequest {
+    /** connection identifier */
+    connectionId: string;
+}
+/**
+ * QueryConnectionClientStateRequest is the request type for the
+ * Query/ConnectionClientState RPC method
+ */
+export interface QueryConnectionClientStateRequestSDKType {
+    /** connection identifier */
+    connection_id: string;
+}
+/**
+ * QueryConnectionClientStateResponse is the response type for the
+ * Query/ConnectionClientState RPC method
+ */
+export interface QueryConnectionClientStateResponse {
+    /** client state associated with the channel */
+    identifiedClientState?: IdentifiedClientState;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proofHeight?: Height;
+}
+/**
+ * QueryConnectionClientStateResponse is the response type for the
+ * Query/ConnectionClientState RPC method
+ */
+export interface QueryConnectionClientStateResponseSDKType {
+    /** client state associated with the channel */
+    identified_client_state?: IdentifiedClientStateSDKType;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proof_height?: HeightSDKType;
+}
+/**
+ * QueryConnectionConsensusStateRequest is the request type for the
+ * Query/ConnectionConsensusState RPC method
+ */
+export interface QueryConnectionConsensusStateRequest {
+    /** connection identifier */
+    connectionId: string;
+    revisionNumber: Long;
+    revisionHeight: Long;
+}
+/**
+ * QueryConnectionConsensusStateRequest is the request type for the
+ * Query/ConnectionConsensusState RPC method
+ */
+export interface QueryConnectionConsensusStateRequestSDKType {
+    /** connection identifier */
+    connection_id: string;
+    revision_number: Long;
+    revision_height: Long;
+}
+/**
+ * QueryConnectionConsensusStateResponse is the response type for the
+ * Query/ConnectionConsensusState RPC method
+ */
+export interface QueryConnectionConsensusStateResponse {
+    /** consensus state associated with the channel */
+    consensusState?: Any;
+    /** client ID associated with the consensus state */
+    clientId: string;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proofHeight?: Height;
+}
+/**
+ * QueryConnectionConsensusStateResponse is the response type for the
+ * Query/ConnectionConsensusState RPC method
+ */
+export interface QueryConnectionConsensusStateResponseSDKType {
+    /** consensus state associated with the channel */
+    consensus_state?: AnySDKType;
+    /** client ID associated with the consensus state */
+    client_id: string;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proof_height?: HeightSDKType;
+}
+export declare const QueryConnectionRequest: {
+    encode(message: QueryConnectionRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionRequest;
+    fromPartial(object: DeepPartial<QueryConnectionRequest>): QueryConnectionRequest;
+};
+export declare const QueryConnectionResponse: {
+    encode(message: QueryConnectionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionResponse;
+    fromPartial(object: DeepPartial<QueryConnectionResponse>): QueryConnectionResponse;
+};
+export declare const QueryConnectionsRequest: {
+    encode(message: QueryConnectionsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionsRequest;
+    fromPartial(object: DeepPartial<QueryConnectionsRequest>): QueryConnectionsRequest;
+};
+export declare const QueryConnectionsResponse: {
+    encode(message: QueryConnectionsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionsResponse;
+    fromPartial(object: DeepPartial<QueryConnectionsResponse>): QueryConnectionsResponse;
+};
+export declare const QueryClientConnectionsRequest: {
+    encode(message: QueryClientConnectionsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientConnectionsRequest;
+    fromPartial(object: DeepPartial<QueryClientConnectionsRequest>): QueryClientConnectionsRequest;
+};
+export declare const QueryClientConnectionsResponse: {
+    encode(message: QueryClientConnectionsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientConnectionsResponse;
+    fromPartial(object: DeepPartial<QueryClientConnectionsResponse>): QueryClientConnectionsResponse;
+};
+export declare const QueryConnectionClientStateRequest: {
+    encode(message: QueryConnectionClientStateRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionClientStateRequest;
+    fromPartial(object: DeepPartial<QueryConnectionClientStateRequest>): QueryConnectionClientStateRequest;
+};
+export declare const QueryConnectionClientStateResponse: {
+    encode(message: QueryConnectionClientStateResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionClientStateResponse;
+    fromPartial(object: DeepPartial<QueryConnectionClientStateResponse>): QueryConnectionClientStateResponse;
+};
+export declare const QueryConnectionConsensusStateRequest: {
+    encode(message: QueryConnectionConsensusStateRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionConsensusStateRequest;
+    fromPartial(object: DeepPartial<QueryConnectionConsensusStateRequest>): QueryConnectionConsensusStateRequest;
+};
+export declare const QueryConnectionConsensusStateResponse: {
+    encode(message: QueryConnectionConsensusStateResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionConsensusStateResponse;
+    fromPartial(object: DeepPartial<QueryConnectionConsensusStateResponse>): QueryConnectionConsensusStateResponse;
+};

package/types/codegen/ibc/core/connection/v1/query.lcd.d.ts

@@ -0,0 +1,13 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryConnectionRequest, QueryConnectionResponseSDKType, QueryConnectionsRequest, QueryConnectionsResponseSDKType, QueryClientConnectionsRequest, QueryClientConnectionsResponseSDKType, QueryConnectionClientStateRequest, QueryConnectionClientStateResponseSDKType, QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponseSDKType } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    connection(params: QueryConnectionRequest): Promise<QueryConnectionResponseSDKType>;
+    connections(params?: QueryConnectionsRequest): Promise<QueryConnectionsResponseSDKType>;
+    clientConnections(params: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponseSDKType>;
+    connectionClientState(params: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponseSDKType>;
+    connectionConsensusState(params: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponseSDKType>;
+}

package/types/codegen/ibc/core/connection/v1/query.rpc.query.d.ts

@@ -0,0 +1,41 @@
+import { Rpc } from "../../../../helpers";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryConnectionRequest, QueryConnectionResponse, QueryConnectionsRequest, QueryConnectionsResponse, QueryClientConnectionsRequest, QueryClientConnectionsResponse, QueryConnectionClientStateRequest, QueryConnectionClientStateResponse, QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponse } from "./query";
+/** Query provides defines the gRPC querier service */
+export interface Query {
+    /** Connection queries an IBC connection end. */
+    connection(request: QueryConnectionRequest): Promise<QueryConnectionResponse>;
+    /** Connections queries all the IBC connections of a chain. */
+    connections(request?: QueryConnectionsRequest): Promise<QueryConnectionsResponse>;
+    /**
+     * ClientConnections queries the connection paths associated with a client
+     * state.
+     */
+    clientConnections(request: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponse>;
+    /**
+     * ConnectionClientState queries the client state associated with the
+     * connection.
+     */
+    connectionClientState(request: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponse>;
+    /**
+     * ConnectionConsensusState queries the consensus state associated with the
+     * connection.
+     */
+    connectionConsensusState(request: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    connection(request: QueryConnectionRequest): Promise<QueryConnectionResponse>;
+    connections(request?: QueryConnectionsRequest): Promise<QueryConnectionsResponse>;
+    clientConnections(request: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponse>;
+    connectionClientState(request: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponse>;
+    connectionConsensusState(request: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    connection(request: QueryConnectionRequest): Promise<QueryConnectionResponse>;
+    connections(request?: QueryConnectionsRequest): Promise<QueryConnectionsResponse>;
+    clientConnections(request: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponse>;
+    connectionClientState(request: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponse>;
+    connectionConsensusState(request: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponse>;
+};