swagger: '2.0'
info:
  title: IBC-GO - gRPC Gateway docs
  description: A REST interface for state queries
  version: 1.0.0
paths:
  '/ibc/apps/transfer/v1/channels/{channel_id}/ports/{port_id}/escrow_address':
    get:
      summary: >-
        EscrowAddress returns the escrow address for a particular port and
        channel id.
      operationId: EscrowAddress
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              escrow_address:
                type: string
                title: the escrow account address
            description: >-
              QueryEscrowAddressResponse is the response type of the
              EscrowAddress RPC method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                    value:
                      type: string
                      format: byte
      parameters:
        - name: channel_id
          description: unique channel identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: unique port identifier
          in: path
          required: true
          type: string
      tags:
        - Query
  '/ibc/apps/transfer/v1/denom_hashes/{trace}':
    get:
      summary: DenomHash queries a denomination hash information.
      operationId: DenomHash
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              hash:
                type: string
                description: hash (in hex format) of the denomination trace information.
            description: >-
              QueryDenomHashResponse is the response type for the
              Query/DenomHash RPC

              method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                    value:
                      type: string
                      format: byte
      parameters:
        - name: trace
          description: 'The denomination trace ([port_id]/[channel_id])+/[denom]'
          in: path
          required: true
          type: string
      tags:
        - Query
  /ibc/apps/transfer/v1/denom_traces:
    get:
      summary: DenomTraces queries all denomination traces.
      operationId: DenomTraces
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              denom_traces:
                type: array
                items:
                  type: object
                  properties:
                    path:
                      type: string
                      description: >-
                        path defines the chain of port/channel identifiers used
                        for tracing the

                        source of the fungible token.
                    base_denom:
                      type: string
                      description: base denomination of the relayed fungible token.
                  description: >-
                    DenomTrace contains the base denomination for ICS20 fungible
                    tokens and the

                    source tracing information path.
                description: denom_traces returns all denominations trace information.
              pagination:
                description: pagination defines the pagination in the response.
                type: object
                properties:
                  next_key:
                    type: string
                    format: byte
                    title: |-
                      next_key is the key to be passed to PageRequest.key to
                      query the next page most efficiently
                  total:
                    type: string
                    format: uint64
                    title: >-
                      total is total number of results available if
                      PageRequest.count_total

                      was set, its value is undefined otherwise
            description: >-
              QueryConnectionsResponse is the response type for the
              Query/DenomTraces RPC

              method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                    value:
                      type: string
                      format: byte
      parameters:
        - name: pagination.key
          description: |-
            key is a value returned in PageResponse.next_key to begin
            querying the next page most efficiently. Only one of offset or key
            should be set.
          in: query
          required: false
          type: string
          format: byte
        - name: pagination.offset
          description: >-
            offset is a numeric offset that can be used when key is unavailable.

            It is less efficient than using key. Only one of offset or key
            should

            be set.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.limit
          description: >-
            limit is the total number of results to be returned in the result
            page.

            If left empty it will default to a value to be set by each app.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.count_total
          description: >-
            count_total is set to true  to indicate that the result set should
            include

            a count of the total number of items available for pagination in
            UIs.

            count_total is only respected when offset is used. It is ignored
            when key

            is set.
          in: query
          required: false
          type: boolean
          format: boolean
      tags:
        - Query
  '/ibc/apps/transfer/v1/denom_traces/{hash}':
    get:
      summary: DenomTrace queries a denomination trace information.
      operationId: DenomTrace
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              denom_trace:
                type: object
                properties:
                  path:
                    type: string
                    description: >-
                      path defines the chain of port/channel identifiers used
                      for tracing the

                      source of the fungible token.
                  base_denom:
                    type: string
                    description: base denomination of the relayed fungible token.
                description: >-
                  DenomTrace contains the base denomination for ICS20 fungible
                  tokens and the

                  source tracing information path.
            description: >-
              QueryDenomTraceResponse is the response type for the
              Query/DenomTrace RPC

              method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                    value:
                      type: string
                      format: byte
      parameters:
        - name: hash
          description: >-
            hash (in hex format) or denom (full denom with ibc prefix) of the
            denomination trace information.
          in: path
          required: true
          type: string
      tags:
        - Query
  /ibc/apps/transfer/v1/params:
    get:
      summary: Params queries all parameters of the ibc-transfer module.
      operationId: TransferParams
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              params:
                description: params defines the parameters of the module.
                type: object
                properties:
                  send_enabled:
                    type: boolean
                    format: boolean
                    description: >-
                      send_enabled enables or disables all cross-chain token
                      transfers from this

                      chain.
                  receive_enabled:
                    type: boolean
                    format: boolean
                    description: >-
                      receive_enabled enables or disables all cross-chain token
                      transfers to this

                      chain.
            description: >-
              QueryParamsResponse is the response type for the Query/Params RPC
              method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                    value:
                      type: string
                      format: byte
      tags:
        - Query
  '/ibc/apps/interchain_accounts/controller/v1/owners/{owner}/connections/{connection_id}':
    get:
      summary: >-
        InterchainAccount returns the interchain account address for a given
        owner address on a given connection
      operationId: InterchainAccount
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              address:
                type: string
            description: >-
              QueryInterchainAccountResponse the response type for the
              Query/InterchainAccount RPC method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                    value:
                      type: string
                      format: byte
      parameters:
        - name: owner
          in: path
          required: true
          type: string
        - name: connection_id
          in: path
          required: true
          type: string
      tags:
        - Query
  /ibc/apps/interchain_accounts/controller/v1/params:
    get:
      summary: Params queries all parameters of the ICA controller submodule.
      operationId: InterchainAccountsControllerParams
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              params:
                description: params defines the parameters of the module.
                type: object
                properties:
                  controller_enabled:
                    type: boolean
                    format: boolean
                    description: >-
                      controller_enabled enables or disables the controller
                      submodule.
            description: >-
              QueryParamsResponse is the response type for the Query/Params RPC
              method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                    value:
                      type: string
                      format: byte
      tags:
        - Query
  /ibc/apps/interchain_accounts/host/v1/params:
    get:
      summary: Params queries all parameters of the ICA host submodule.
      operationId: InterchainAccountsHostParams
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              params:
                description: params defines the parameters of the module.
                type: object
                properties:
                  host_enabled:
                    type: boolean
                    format: boolean
                    description: host_enabled enables or disables the host submodule.
                  allow_messages:
                    type: array
                    items:
                      type: string
                    description: >-
                      allow_messages defines a list of sdk message typeURLs
                      allowed to be executed on a host chain.
            description: >-
              QueryParamsResponse is the response type for the Query/Params RPC
              method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                    value:
                      type: string
                      format: byte
      tags:
        - Query
  /ibc/client/v1/params:
    get:
      summary: ClientParams queries all parameters of the ibc client.
      operationId: ClientParams
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              params:
                description: params defines the parameters of the module.
                type: object
                properties:
                  allowed_clients:
                    type: array
                    items:
                      type: string
                    description: >-
                      allowed_clients defines the list of allowed client state
                      types.
            description: >-
              QueryClientParamsResponse is the response type for the
              Query/ClientParams RPC

              method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      tags:
        - Query
  /ibc/core/client/v1/client_states:
    get:
      summary: ClientStates queries all the IBC light clients of a chain.
      operationId: ClientStates
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              client_states:
                type: array
                items:
                  type: object
                  properties:
                    client_id:
                      type: string
                      title: client identifier
                    client_state:
                      type: object
                      properties:
                        type_url:
                          type: string
                          description: >-
                            A URL/resource name that uniquely identifies the
                            type of the serialized

                            protocol buffer message. This string must contain at
                            least

                            one "/" character. The last segment of the URL's
                            path must represent

                            the fully qualified name of the type (as in

                            `path/google.protobuf.Duration`). The name should be
                            in a canonical form

                            (e.g., leading "." is not accepted).


                            In practice, teams usually precompile into the
                            binary all types that they

                            expect it to use in the context of Any. However, for
                            URLs which use the

                            scheme `http`, `https`, or no scheme, one can
                            optionally set up a type

                            server that maps type URLs to message definitions as
                            follows:


                            * If no scheme is provided, `https` is assumed.

                            * An HTTP GET on the URL must yield a
                            [google.protobuf.Type][]
                              value in binary format, or produce an error.
                            * Applications are allowed to cache lookup results
                            based on the
                              URL, or have them precompiled into a binary to avoid any
                              lookup. Therefore, binary compatibility needs to be preserved
                              on changes to types. (Use versioned type names to manage
                              breaking changes.)

                            Note: this functionality is not currently available
                            in the official

                            protobuf release, and it is not used for type URLs
                            beginning with

                            type.googleapis.com.


                            Schemes other than `http`, `https` (or the empty
                            scheme) might be

                            used with implementation specific semantics.
                        value:
                          type: string
                          format: byte
                          description: >-
                            Must be a valid serialized protocol buffer of the
                            above specified type.
                      description: >-
                        `Any` contains an arbitrary serialized protocol buffer
                        message along with a

                        URL that describes the type of the serialized message.


                        Protobuf library provides support to pack/unpack Any
                        values in the form

                        of utility functions or additional generated methods of
                        the Any type.


                        Example 1: Pack and unpack a message in C++.

                            Foo foo = ...;
                            Any any;
                            any.PackFrom(foo);
                            ...
                            if (any.UnpackTo(&foo)) {
                              ...
                            }

                        Example 2: Pack and unpack a message in Java.

                            Foo foo = ...;
                            Any any = Any.pack(foo);
                            ...
                            if (any.is(Foo.class)) {
                              foo = any.unpack(Foo.class);
                            }

                         Example 3: Pack and unpack a message in Python.

                            foo = Foo(...)
                            any = Any()
                            any.Pack(foo)
                            ...
                            if any.Is(Foo.DESCRIPTOR):
                              any.Unpack(foo)
                              ...

                         Example 4: Pack and unpack a message in Go

                             foo := &pb.Foo{...}
                             any, err := ptypes.MarshalAny(foo)
                             ...
                             foo := &pb.Foo{}
                             if err := ptypes.UnmarshalAny(any, foo); err != nil {
                               ...
                             }

                        The pack methods provided by protobuf library will by
                        default use

                        'type.googleapis.com/full.type.name' as the type URL and
                        the unpack

                        methods only use the fully qualified type name after the
                        last '/'

                        in the type URL, for example "foo.bar.com/x/y.z" will
                        yield type

                        name "y.z".



                        JSON

                        ====

                        The JSON representation of an `Any` value uses the
                        regular

                        representation of the deserialized, embedded message,
                        with an

                        additional field `@type` which contains the type URL.
                        Example:

                            package google.profile;
                            message Person {
                              string first_name = 1;
                              string last_name = 2;
                            }

                            {
                              "@type": "type.googleapis.com/google.profile.Person",
                              "firstName": <string>,
                              "lastName": <string>
                            }

                        If the embedded message type is well-known and has a
                        custom JSON

                        representation, that representation will be embedded
                        adding a field

                        `value` which holds the custom JSON in addition to the
                        `@type`

                        field. Example (for message
                        [google.protobuf.Duration][]):

                            {
                              "@type": "type.googleapis.com/google.protobuf.Duration",
                              "value": "1.212s"
                            }
                      title: client state
                  description: >-
                    IdentifiedClientState defines a client state with an
                    additional client

                    identifier field.
                description: list of stored ClientStates of the chain.
              pagination:
                title: pagination response
                type: object
                properties:
                  next_key:
                    type: string
                    format: byte
                    title: |-
                      next_key is the key to be passed to PageRequest.key to
                      query the next page most efficiently
                  total:
                    type: string
                    format: uint64
                    title: >-
                      total is total number of results available if
                      PageRequest.count_total

                      was set, its value is undefined otherwise
                description: >-
                  PageResponse is to be embedded in gRPC response messages where
                  the

                  corresponding request message has used PageRequest.

                   message SomeResponse {
                           repeated Bar results = 1;
                           PageResponse page = 2;
                   }
            description: >-
              QueryClientStatesResponse is the response type for the
              Query/ClientStates RPC

              method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: pagination.key
          description: |-
            key is a value returned in PageResponse.next_key to begin
            querying the next page most efficiently. Only one of offset or key
            should be set.
          in: query
          required: false
          type: string
          format: byte
        - name: pagination.offset
          description: >-
            offset is a numeric offset that can be used when key is unavailable.

            It is less efficient than using key. Only one of offset or key
            should

            be set.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.limit
          description: >-
            limit is the total number of results to be returned in the result
            page.

            If left empty it will default to a value to be set by each app.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.count_total
          description: >-
            count_total is set to true  to indicate that the result set should
            include

            a count of the total number of items available for pagination in
            UIs.

            count_total is only respected when offset is used. It is ignored
            when key

            is set.
          in: query
          required: false
          type: boolean
          format: boolean
      tags:
        - Query
  '/ibc/core/client/v1/client_states/{client_id}':
    get:
      summary: ClientState queries an IBC light client.
      operationId: ClientState
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              client_state:
                type: object
                properties:
                  type_url:
                    type: string
                    description: >-
                      A URL/resource name that uniquely identifies the type of
                      the serialized

                      protocol buffer message. This string must contain at least

                      one "/" character. The last segment of the URL's path must
                      represent

                      the fully qualified name of the type (as in

                      `path/google.protobuf.Duration`). The name should be in a
                      canonical form

                      (e.g., leading "." is not accepted).


                      In practice, teams usually precompile into the binary all
                      types that they

                      expect it to use in the context of Any. However, for URLs
                      which use the

                      scheme `http`, `https`, or no scheme, one can optionally
                      set up a type

                      server that maps type URLs to message definitions as
                      follows:


                      * If no scheme is provided, `https` is assumed.

                      * An HTTP GET on the URL must yield a
                      [google.protobuf.Type][]
                        value in binary format, or produce an error.
                      * Applications are allowed to cache lookup results based
                      on the
                        URL, or have them precompiled into a binary to avoid any
                        lookup. Therefore, binary compatibility needs to be preserved
                        on changes to types. (Use versioned type names to manage
                        breaking changes.)

                      Note: this functionality is not currently available in the
                      official

                      protobuf release, and it is not used for type URLs
                      beginning with

                      type.googleapis.com.


                      Schemes other than `http`, `https` (or the empty scheme)
                      might be

                      used with implementation specific semantics.
                  value:
                    type: string
                    format: byte
                    description: >-
                      Must be a valid serialized protocol buffer of the above
                      specified type.
                description: >-
                  `Any` contains an arbitrary serialized protocol buffer message
                  along with a

                  URL that describes the type of the serialized message.


                  Protobuf library provides support to pack/unpack Any values in
                  the form

                  of utility functions or additional generated methods of the
                  Any type.


                  Example 1: Pack and unpack a message in C++.

                      Foo foo = ...;
                      Any any;
                      any.PackFrom(foo);
                      ...
                      if (any.UnpackTo(&foo)) {
                        ...
                      }

                  Example 2: Pack and unpack a message in Java.

                      Foo foo = ...;
                      Any any = Any.pack(foo);
                      ...
                      if (any.is(Foo.class)) {
                        foo = any.unpack(Foo.class);
                      }

                   Example 3: Pack and unpack a message in Python.

                      foo = Foo(...)
                      any = Any()
                      any.Pack(foo)
                      ...
                      if any.Is(Foo.DESCRIPTOR):
                        any.Unpack(foo)
                        ...

                   Example 4: Pack and unpack a message in Go

                       foo := &pb.Foo{...}
                       any, err := ptypes.MarshalAny(foo)
                       ...
                       foo := &pb.Foo{}
                       if err := ptypes.UnmarshalAny(any, foo); err != nil {
                         ...
                       }

                  The pack methods provided by protobuf library will by default
                  use

                  'type.googleapis.com/full.type.name' as the type URL and the
                  unpack

                  methods only use the fully qualified type name after the last
                  '/'

                  in the type URL, for example "foo.bar.com/x/y.z" will yield
                  type

                  name "y.z".



                  JSON

                  ====

                  The JSON representation of an `Any` value uses the regular

                  representation of the deserialized, embedded message, with an

                  additional field `@type` which contains the type URL. Example:

                      package google.profile;
                      message Person {
                        string first_name = 1;
                        string last_name = 2;
                      }

                      {
                        "@type": "type.googleapis.com/google.profile.Person",
                        "firstName": <string>,
                        "lastName": <string>
                      }

                  If the embedded message type is well-known and has a custom
                  JSON

                  representation, that representation will be embedded adding a
                  field

                  `value` which holds the custom JSON in addition to the `@type`

                  field. Example (for message [google.protobuf.Duration][]):

                      {
                        "@type": "type.googleapis.com/google.protobuf.Duration",
                        "value": "1.212s"
                      }
                title: client state associated with the request identifier
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            description: >-
              QueryClientStateResponse is the response type for the
              Query/ClientState RPC

              method. Besides the client state, it includes a proof and the
              height from

              which the proof was retrieved.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: client_id
          description: client state unique identifier
          in: path
          required: true
          type: string
      tags:
        - Query
  '/ibc/core/client/v1/client_status/{client_id}':
    get:
      summary: Status queries the status of an IBC client.
      operationId: ClientStatus
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              status:
                type: string
            description: >-
              QueryClientStatusResponse is the response type for the
              Query/ClientStatus RPC

              method. It returns the current status of the IBC client.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: client_id
          description: client unique identifier
          in: path
          required: true
          type: string
      tags:
        - Query
  '/ibc/core/client/v1/consensus_states/{client_id}':
    get:
      summary: |-
        ConsensusStates queries all the consensus state associated with a given
        client.
      operationId: ConsensusStates
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              consensus_states:
                type: array
                items:
                  type: object
                  properties:
                    height:
                      title: consensus state height
                      type: object
                      properties:
                        revision_number:
                          type: string
                          format: uint64
                          title: the revision that the client is currently on
                        revision_height:
                          type: string
                          format: uint64
                          title: the height within the given revision
                      description: >-
                        Normally the RevisionHeight is incremented at each
                        height while keeping

                        RevisionNumber the same. However some consensus
                        algorithms may choose to

                        reset the height in certain conditions e.g. hard forks,
                        state-machine

                        breaking changes In these cases, the RevisionNumber is
                        incremented so that

                        height continues to be monitonically increasing even as
                        the RevisionHeight

                        gets reset
                    consensus_state:
                      type: object
                      properties:
                        type_url:
                          type: string
                          description: >-
                            A URL/resource name that uniquely identifies the
                            type of the serialized

                            protocol buffer message. This string must contain at
                            least

                            one "/" character. The last segment of the URL's
                            path must represent

                            the fully qualified name of the type (as in

                            `path/google.protobuf.Duration`). The name should be
                            in a canonical form

                            (e.g., leading "." is not accepted).


                            In practice, teams usually precompile into the
                            binary all types that they

                            expect it to use in the context of Any. However, for
                            URLs which use the

                            scheme `http`, `https`, or no scheme, one can
                            optionally set up a type

                            server that maps type URLs to message definitions as
                            follows:


                            * If no scheme is provided, `https` is assumed.

                            * An HTTP GET on the URL must yield a
                            [google.protobuf.Type][]
                              value in binary format, or produce an error.
                            * Applications are allowed to cache lookup results
                            based on the
                              URL, or have them precompiled into a binary to avoid any
                              lookup. Therefore, binary compatibility needs to be preserved
                              on changes to types. (Use versioned type names to manage
                              breaking changes.)

                            Note: this functionality is not currently available
                            in the official

                            protobuf release, and it is not used for type URLs
                            beginning with

                            type.googleapis.com.


                            Schemes other than `http`, `https` (or the empty
                            scheme) might be

                            used with implementation specific semantics.
                        value:
                          type: string
                          format: byte
                          description: >-
                            Must be a valid serialized protocol buffer of the
                            above specified type.
                      description: >-
                        `Any` contains an arbitrary serialized protocol buffer
                        message along with a

                        URL that describes the type of the serialized message.


                        Protobuf library provides support to pack/unpack Any
                        values in the form

                        of utility functions or additional generated methods of
                        the Any type.


                        Example 1: Pack and unpack a message in C++.

                            Foo foo = ...;
                            Any any;
                            any.PackFrom(foo);
                            ...
                            if (any.UnpackTo(&foo)) {
                              ...
                            }

                        Example 2: Pack and unpack a message in Java.

                            Foo foo = ...;
                            Any any = Any.pack(foo);
                            ...
                            if (any.is(Foo.class)) {
                              foo = any.unpack(Foo.class);
                            }

                         Example 3: Pack and unpack a message in Python.

                            foo = Foo(...)
                            any = Any()
                            any.Pack(foo)
                            ...
                            if any.Is(Foo.DESCRIPTOR):
                              any.Unpack(foo)
                              ...

                         Example 4: Pack and unpack a message in Go

                             foo := &pb.Foo{...}
                             any, err := ptypes.MarshalAny(foo)
                             ...
                             foo := &pb.Foo{}
                             if err := ptypes.UnmarshalAny(any, foo); err != nil {
                               ...
                             }

                        The pack methods provided by protobuf library will by
                        default use

                        'type.googleapis.com/full.type.name' as the type URL and
                        the unpack

                        methods only use the fully qualified type name after the
                        last '/'

                        in the type URL, for example "foo.bar.com/x/y.z" will
                        yield type

                        name "y.z".



                        JSON

                        ====

                        The JSON representation of an `Any` value uses the
                        regular

                        representation of the deserialized, embedded message,
                        with an

                        additional field `@type` which contains the type URL.
                        Example:

                            package google.profile;
                            message Person {
                              string first_name = 1;
                              string last_name = 2;
                            }

                            {
                              "@type": "type.googleapis.com/google.profile.Person",
                              "firstName": <string>,
                              "lastName": <string>
                            }

                        If the embedded message type is well-known and has a
                        custom JSON

                        representation, that representation will be embedded
                        adding a field

                        `value` which holds the custom JSON in addition to the
                        `@type`

                        field. Example (for message
                        [google.protobuf.Duration][]):

                            {
                              "@type": "type.googleapis.com/google.protobuf.Duration",
                              "value": "1.212s"
                            }
                      title: consensus state
                  description: >-
                    ConsensusStateWithHeight defines a consensus state with an
                    additional height

                    field.
                title: consensus states associated with the identifier
              pagination:
                title: pagination response
                type: object
                properties:
                  next_key:
                    type: string
                    format: byte
                    title: |-
                      next_key is the key to be passed to PageRequest.key to
                      query the next page most efficiently
                  total:
                    type: string
                    format: uint64
                    title: >-
                      total is total number of results available if
                      PageRequest.count_total

                      was set, its value is undefined otherwise
                description: >-
                  PageResponse is to be embedded in gRPC response messages where
                  the

                  corresponding request message has used PageRequest.

                   message SomeResponse {
                           repeated Bar results = 1;
                           PageResponse page = 2;
                   }
            title: |-
              QueryConsensusStatesResponse is the response type for the
              Query/ConsensusStates RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: client_id
          description: client identifier
          in: path
          required: true
          type: string
        - name: pagination.key
          description: |-
            key is a value returned in PageResponse.next_key to begin
            querying the next page most efficiently. Only one of offset or key
            should be set.
          in: query
          required: false
          type: string
          format: byte
        - name: pagination.offset
          description: >-
            offset is a numeric offset that can be used when key is unavailable.

            It is less efficient than using key. Only one of offset or key
            should

            be set.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.limit
          description: >-
            limit is the total number of results to be returned in the result
            page.

            If left empty it will default to a value to be set by each app.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.count_total
          description: >-
            count_total is set to true  to indicate that the result set should
            include

            a count of the total number of items available for pagination in
            UIs.

            count_total is only respected when offset is used. It is ignored
            when key

            is set.
          in: query
          required: false
          type: boolean
          format: boolean
      tags:
        - Query
  '/ibc/core/client/v1/consensus_states/{client_id}/heights':
    get:
      summary: >-
        ConsensusStateHeights queries the height of every consensus states
        associated with a given client.
      operationId: ConsensusStateHeights
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              consensus_state_heights:
                type: array
                items:
                  type: object
                  properties:
                    revision_number:
                      type: string
                      format: uint64
                      title: the revision that the client is currently on
                    revision_height:
                      type: string
                      format: uint64
                      title: the height within the given revision
                  description: >-
                    Normally the RevisionHeight is incremented at each height
                    while keeping

                    RevisionNumber the same. However some consensus algorithms
                    may choose to

                    reset the height in certain conditions e.g. hard forks,
                    state-machine

                    breaking changes In these cases, the RevisionNumber is
                    incremented so that

                    height continues to be monitonically increasing even as the
                    RevisionHeight

                    gets reset
                  title: >-
                    Height is a monotonically increasing data type

                    that can be compared against another Height for the purposes
                    of updating and

                    freezing clients
                title: consensus state heights
              pagination:
                title: pagination response
                type: object
                properties:
                  next_key:
                    type: string
                    format: byte
                    title: |-
                      next_key is the key to be passed to PageRequest.key to
                      query the next page most efficiently
                  total:
                    type: string
                    format: uint64
                    title: >-
                      total is total number of results available if
                      PageRequest.count_total

                      was set, its value is undefined otherwise
                description: >-
                  PageResponse is to be embedded in gRPC response messages where
                  the

                  corresponding request message has used PageRequest.

                   message SomeResponse {
                           repeated Bar results = 1;
                           PageResponse page = 2;
                   }
            title: |-
              QueryConsensusStateHeightsResponse is the response type for the
              Query/ConsensusStateHeights RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: client_id
          description: client identifier
          in: path
          required: true
          type: string
        - name: pagination.key
          description: |-
            key is a value returned in PageResponse.next_key to begin
            querying the next page most efficiently. Only one of offset or key
            should be set.
          in: query
          required: false
          type: string
          format: byte
        - name: pagination.offset
          description: >-
            offset is a numeric offset that can be used when key is unavailable.

            It is less efficient than using key. Only one of offset or key
            should

            be set.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.limit
          description: >-
            limit is the total number of results to be returned in the result
            page.

            If left empty it will default to a value to be set by each app.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.count_total
          description: >-
            count_total is set to true  to indicate that the result set should
            include

            a count of the total number of items available for pagination in
            UIs.

            count_total is only respected when offset is used. It is ignored
            when key

            is set.
          in: query
          required: false
          type: boolean
          format: boolean
      tags:
        - Query
  '/ibc/core/client/v1/consensus_states/{client_id}/revision/{revision_number}/height/{revision_height}':
    get:
      summary: >-
        ConsensusState queries a consensus state associated with a client state
        at

        a given height.
      operationId: ConsensusState
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              consensus_state:
                type: object
                properties:
                  type_url:
                    type: string
                    description: >-
                      A URL/resource name that uniquely identifies the type of
                      the serialized

                      protocol buffer message. This string must contain at least

                      one "/" character. The last segment of the URL's path must
                      represent

                      the fully qualified name of the type (as in

                      `path/google.protobuf.Duration`). The name should be in a
                      canonical form

                      (e.g., leading "." is not accepted).


                      In practice, teams usually precompile into the binary all
                      types that they

                      expect it to use in the context of Any. However, for URLs
                      which use the

                      scheme `http`, `https`, or no scheme, one can optionally
                      set up a type

                      server that maps type URLs to message definitions as
                      follows:


                      * If no scheme is provided, `https` is assumed.

                      * An HTTP GET on the URL must yield a
                      [google.protobuf.Type][]
                        value in binary format, or produce an error.
                      * Applications are allowed to cache lookup results based
                      on the
                        URL, or have them precompiled into a binary to avoid any
                        lookup. Therefore, binary compatibility needs to be preserved
                        on changes to types. (Use versioned type names to manage
                        breaking changes.)

                      Note: this functionality is not currently available in the
                      official

                      protobuf release, and it is not used for type URLs
                      beginning with

                      type.googleapis.com.


                      Schemes other than `http`, `https` (or the empty scheme)
                      might be

                      used with implementation specific semantics.
                  value:
                    type: string
                    format: byte
                    description: >-
                      Must be a valid serialized protocol buffer of the above
                      specified type.
                description: >-
                  `Any` contains an arbitrary serialized protocol buffer message
                  along with a

                  URL that describes the type of the serialized message.


                  Protobuf library provides support to pack/unpack Any values in
                  the form

                  of utility functions or additional generated methods of the
                  Any type.


                  Example 1: Pack and unpack a message in C++.

                      Foo foo = ...;
                      Any any;
                      any.PackFrom(foo);
                      ...
                      if (any.UnpackTo(&foo)) {
                        ...
                      }

                  Example 2: Pack and unpack a message in Java.

                      Foo foo = ...;
                      Any any = Any.pack(foo);
                      ...
                      if (any.is(Foo.class)) {
                        foo = any.unpack(Foo.class);
                      }

                   Example 3: Pack and unpack a message in Python.

                      foo = Foo(...)
                      any = Any()
                      any.Pack(foo)
                      ...
                      if any.Is(Foo.DESCRIPTOR):
                        any.Unpack(foo)
                        ...

                   Example 4: Pack and unpack a message in Go

                       foo := &pb.Foo{...}
                       any, err := ptypes.MarshalAny(foo)
                       ...
                       foo := &pb.Foo{}
                       if err := ptypes.UnmarshalAny(any, foo); err != nil {
                         ...
                       }

                  The pack methods provided by protobuf library will by default
                  use

                  'type.googleapis.com/full.type.name' as the type URL and the
                  unpack

                  methods only use the fully qualified type name after the last
                  '/'

                  in the type URL, for example "foo.bar.com/x/y.z" will yield
                  type

                  name "y.z".



                  JSON

                  ====

                  The JSON representation of an `Any` value uses the regular

                  representation of the deserialized, embedded message, with an

                  additional field `@type` which contains the type URL. Example:

                      package google.profile;
                      message Person {
                        string first_name = 1;
                        string last_name = 2;
                      }

                      {
                        "@type": "type.googleapis.com/google.profile.Person",
                        "firstName": <string>,
                        "lastName": <string>
                      }

                  If the embedded message type is well-known and has a custom
                  JSON

                  representation, that representation will be embedded adding a
                  field

                  `value` which holds the custom JSON in addition to the `@type`

                  field. Example (for message [google.protobuf.Duration][]):

                      {
                        "@type": "type.googleapis.com/google.protobuf.Duration",
                        "value": "1.212s"
                      }
                title: >-
                  consensus state associated with the client identifier at the
                  given height
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
                title: >-
                  Height is a monotonically increasing data type

                  that can be compared against another Height for the purposes
                  of updating and

                  freezing clients
            title: >-
              QueryConsensusStateResponse is the response type for the
              Query/ConsensusState

              RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: client_id
          description: client identifier
          in: path
          required: true
          type: string
        - name: revision_number
          description: consensus state revision number
          in: path
          required: true
          type: string
          format: uint64
        - name: revision_height
          description: consensus state revision height
          in: path
          required: true
          type: string
          format: uint64
        - name: latest_height
          description: >-
            latest_height overrrides the height field and queries the latest
            stored

            ConsensusState.
          in: query
          required: false
          type: boolean
          format: boolean
      tags:
        - Query
  /ibc/core/client/v1/upgraded_client_states:
    get:
      summary: UpgradedClientState queries an Upgraded IBC light client.
      operationId: UpgradedClientState
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              upgraded_client_state:
                type: object
                properties:
                  type_url:
                    type: string
                    description: >-
                      A URL/resource name that uniquely identifies the type of
                      the serialized

                      protocol buffer message. This string must contain at least

                      one "/" character. The last segment of the URL's path must
                      represent

                      the fully qualified name of the type (as in

                      `path/google.protobuf.Duration`). The name should be in a
                      canonical form

                      (e.g., leading "." is not accepted).


                      In practice, teams usually precompile into the binary all
                      types that they

                      expect it to use in the context of Any. However, for URLs
                      which use the

                      scheme `http`, `https`, or no scheme, one can optionally
                      set up a type

                      server that maps type URLs to message definitions as
                      follows:


                      * If no scheme is provided, `https` is assumed.

                      * An HTTP GET on the URL must yield a
                      [google.protobuf.Type][]
                        value in binary format, or produce an error.
                      * Applications are allowed to cache lookup results based
                      on the
                        URL, or have them precompiled into a binary to avoid any
                        lookup. Therefore, binary compatibility needs to be preserved
                        on changes to types. (Use versioned type names to manage
                        breaking changes.)

                      Note: this functionality is not currently available in the
                      official

                      protobuf release, and it is not used for type URLs
                      beginning with

                      type.googleapis.com.


                      Schemes other than `http`, `https` (or the empty scheme)
                      might be

                      used with implementation specific semantics.
                  value:
                    type: string
                    format: byte
                    description: >-
                      Must be a valid serialized protocol buffer of the above
                      specified type.
                description: >-
                  `Any` contains an arbitrary serialized protocol buffer message
                  along with a

                  URL that describes the type of the serialized message.


                  Protobuf library provides support to pack/unpack Any values in
                  the form

                  of utility functions or additional generated methods of the
                  Any type.


                  Example 1: Pack and unpack a message in C++.

                      Foo foo = ...;
                      Any any;
                      any.PackFrom(foo);
                      ...
                      if (any.UnpackTo(&foo)) {
                        ...
                      }

                  Example 2: Pack and unpack a message in Java.

                      Foo foo = ...;
                      Any any = Any.pack(foo);
                      ...
                      if (any.is(Foo.class)) {
                        foo = any.unpack(Foo.class);
                      }

                   Example 3: Pack and unpack a message in Python.

                      foo = Foo(...)
                      any = Any()
                      any.Pack(foo)
                      ...
                      if any.Is(Foo.DESCRIPTOR):
                        any.Unpack(foo)
                        ...

                   Example 4: Pack and unpack a message in Go

                       foo := &pb.Foo{...}
                       any, err := ptypes.MarshalAny(foo)
                       ...
                       foo := &pb.Foo{}
                       if err := ptypes.UnmarshalAny(any, foo); err != nil {
                         ...
                       }

                  The pack methods provided by protobuf library will by default
                  use

                  'type.googleapis.com/full.type.name' as the type URL and the
                  unpack

                  methods only use the fully qualified type name after the last
                  '/'

                  in the type URL, for example "foo.bar.com/x/y.z" will yield
                  type

                  name "y.z".



                  JSON

                  ====

                  The JSON representation of an `Any` value uses the regular

                  representation of the deserialized, embedded message, with an

                  additional field `@type` which contains the type URL. Example:

                      package google.profile;
                      message Person {
                        string first_name = 1;
                        string last_name = 2;
                      }

                      {
                        "@type": "type.googleapis.com/google.profile.Person",
                        "firstName": <string>,
                        "lastName": <string>
                      }

                  If the embedded message type is well-known and has a custom
                  JSON

                  representation, that representation will be embedded adding a
                  field

                  `value` which holds the custom JSON in addition to the `@type`

                  field. Example (for message [google.protobuf.Duration][]):

                      {
                        "@type": "type.googleapis.com/google.protobuf.Duration",
                        "value": "1.212s"
                      }
                title: client state associated with the request identifier
            description: |-
              QueryUpgradedClientStateResponse is the response type for the
              Query/UpgradedClientState RPC method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      tags:
        - Query
  /ibc/core/client/v1/upgraded_consensus_states:
    get:
      summary: UpgradedConsensusState queries an Upgraded IBC consensus state.
      operationId: UpgradedConsensusState
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              upgraded_consensus_state:
                type: object
                properties:
                  type_url:
                    type: string
                    description: >-
                      A URL/resource name that uniquely identifies the type of
                      the serialized

                      protocol buffer message. This string must contain at least

                      one "/" character. The last segment of the URL's path must
                      represent

                      the fully qualified name of the type (as in

                      `path/google.protobuf.Duration`). The name should be in a
                      canonical form

                      (e.g., leading "." is not accepted).


                      In practice, teams usually precompile into the binary all
                      types that they

                      expect it to use in the context of Any. However, for URLs
                      which use the

                      scheme `http`, `https`, or no scheme, one can optionally
                      set up a type

                      server that maps type URLs to message definitions as
                      follows:


                      * If no scheme is provided, `https` is assumed.

                      * An HTTP GET on the URL must yield a
                      [google.protobuf.Type][]
                        value in binary format, or produce an error.
                      * Applications are allowed to cache lookup results based
                      on the
                        URL, or have them precompiled into a binary to avoid any
                        lookup. Therefore, binary compatibility needs to be preserved
                        on changes to types. (Use versioned type names to manage
                        breaking changes.)

                      Note: this functionality is not currently available in the
                      official

                      protobuf release, and it is not used for type URLs
                      beginning with

                      type.googleapis.com.


                      Schemes other than `http`, `https` (or the empty scheme)
                      might be

                      used with implementation specific semantics.
                  value:
                    type: string
                    format: byte
                    description: >-
                      Must be a valid serialized protocol buffer of the above
                      specified type.
                description: >-
                  `Any` contains an arbitrary serialized protocol buffer message
                  along with a

                  URL that describes the type of the serialized message.


                  Protobuf library provides support to pack/unpack Any values in
                  the form

                  of utility functions or additional generated methods of the
                  Any type.


                  Example 1: Pack and unpack a message in C++.

                      Foo foo = ...;
                      Any any;
                      any.PackFrom(foo);
                      ...
                      if (any.UnpackTo(&foo)) {
                        ...
                      }

                  Example 2: Pack and unpack a message in Java.

                      Foo foo = ...;
                      Any any = Any.pack(foo);
                      ...
                      if (any.is(Foo.class)) {
                        foo = any.unpack(Foo.class);
                      }

                   Example 3: Pack and unpack a message in Python.

                      foo = Foo(...)
                      any = Any()
                      any.Pack(foo)
                      ...
                      if any.Is(Foo.DESCRIPTOR):
                        any.Unpack(foo)
                        ...

                   Example 4: Pack and unpack a message in Go

                       foo := &pb.Foo{...}
                       any, err := ptypes.MarshalAny(foo)
                       ...
                       foo := &pb.Foo{}
                       if err := ptypes.UnmarshalAny(any, foo); err != nil {
                         ...
                       }

                  The pack methods provided by protobuf library will by default
                  use

                  'type.googleapis.com/full.type.name' as the type URL and the
                  unpack

                  methods only use the fully qualified type name after the last
                  '/'

                  in the type URL, for example "foo.bar.com/x/y.z" will yield
                  type

                  name "y.z".



                  JSON

                  ====

                  The JSON representation of an `Any` value uses the regular

                  representation of the deserialized, embedded message, with an

                  additional field `@type` which contains the type URL. Example:

                      package google.profile;
                      message Person {
                        string first_name = 1;
                        string last_name = 2;
                      }

                      {
                        "@type": "type.googleapis.com/google.profile.Person",
                        "firstName": <string>,
                        "lastName": <string>
                      }

                  If the embedded message type is well-known and has a custom
                  JSON

                  representation, that representation will be embedded adding a
                  field

                  `value` which holds the custom JSON in addition to the `@type`

                  field. Example (for message [google.protobuf.Duration][]):

                      {
                        "@type": "type.googleapis.com/google.protobuf.Duration",
                        "value": "1.212s"
                      }
                title: Consensus state associated with the request identifier
            description: |-
              QueryUpgradedConsensusStateResponse is the response type for the
              Query/UpgradedConsensusState RPC method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      tags:
        - Query
  '/ibc/core/connection/v1/client_connections/{client_id}':
    get:
      summary: |-
        ClientConnections queries the connection paths associated with a client
        state.
      operationId: ClientConnections
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              connection_paths:
                type: array
                items:
                  type: string
                description: slice of all the connection paths associated with a client.
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was generated
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QueryClientConnectionsResponse is the response type for the
              Query/ClientConnections RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: client_id
          description: client identifier associated with a connection
          in: path
          required: true
          type: string
      tags:
        - Query
  /ibc/core/connection/v1/connections:
    get:
      summary: Connections queries all the IBC connections of a chain.
      operationId: Connections
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              connections:
                type: array
                items:
                  type: object
                  properties:
                    id:
                      type: string
                      description: connection identifier.
                    client_id:
                      type: string
                      description: client associated with this connection.
                    versions:
                      type: array
                      items:
                        type: object
                        properties:
                          identifier:
                            type: string
                            title: unique version identifier
                          features:
                            type: array
                            items:
                              type: string
                            title: >-
                              list of features compatible with the specified
                              identifier
                        description: >-
                          Version defines the versioning scheme used to
                          negotiate the IBC verison in

                          the connection handshake.
                      title: >-
                        IBC version which can be utilised to determine encodings
                        or protocols for

                        channels or packets utilising this connection
                    state:
                      description: current state of the connection end.
                      type: string
                      enum:
                        - STATE_UNINITIALIZED_UNSPECIFIED
                        - STATE_INIT
                        - STATE_TRYOPEN
                        - STATE_OPEN
                      default: STATE_UNINITIALIZED_UNSPECIFIED
                    counterparty:
                      description: counterparty chain associated with this connection.
                      type: object
                      properties:
                        client_id:
                          type: string
                          description: >-
                            identifies the client on the counterparty chain
                            associated with a given

                            connection.
                        connection_id:
                          type: string
                          description: >-
                            identifies the connection end on the counterparty
                            chain associated with a

                            given connection.
                        prefix:
                          description: commitment merkle prefix of the counterparty chain.
                          type: object
                          properties:
                            key_prefix:
                              type: string
                              format: byte
                          title: >-
                            MerklePrefix is merkle path prefixed to the key.

                            The constructed key from the Path and the key will
                            be append(Path.KeyPath,

                            append(Path.KeyPrefix, key...))
                    delay_period:
                      type: string
                      format: uint64
                      description: delay period associated with this connection.
                  description: >-
                    IdentifiedConnection defines a connection with additional
                    connection

                    identifier field.
                description: list of stored connections of the chain.
              pagination:
                title: pagination response
                type: object
                properties:
                  next_key:
                    type: string
                    format: byte
                    title: |-
                      next_key is the key to be passed to PageRequest.key to
                      query the next page most efficiently
                  total:
                    type: string
                    format: uint64
                    title: >-
                      total is total number of results available if
                      PageRequest.count_total

                      was set, its value is undefined otherwise
                description: >-
                  PageResponse is to be embedded in gRPC response messages where
                  the

                  corresponding request message has used PageRequest.

                   message SomeResponse {
                           repeated Bar results = 1;
                           PageResponse page = 2;
                   }
              height:
                title: query block height
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            description: >-
              QueryConnectionsResponse is the response type for the
              Query/Connections RPC

              method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: pagination.key
          description: |-
            key is a value returned in PageResponse.next_key to begin
            querying the next page most efficiently. Only one of offset or key
            should be set.
          in: query
          required: false
          type: string
          format: byte
        - name: pagination.offset
          description: >-
            offset is a numeric offset that can be used when key is unavailable.

            It is less efficient than using key. Only one of offset or key
            should

            be set.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.limit
          description: >-
            limit is the total number of results to be returned in the result
            page.

            If left empty it will default to a value to be set by each app.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.count_total
          description: >-
            count_total is set to true  to indicate that the result set should
            include

            a count of the total number of items available for pagination in
            UIs.

            count_total is only respected when offset is used. It is ignored
            when key

            is set.
          in: query
          required: false
          type: boolean
          format: boolean
      tags:
        - Query
  '/ibc/core/connection/v1/connections/{connection_id}':
    get:
      summary: Connection queries an IBC connection end.
      operationId: Connection
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              connection:
                title: connection associated with the request identifier
                type: object
                properties:
                  client_id:
                    type: string
                    description: client associated with this connection.
                  versions:
                    type: array
                    items:
                      type: object
                      properties:
                        identifier:
                          type: string
                          title: unique version identifier
                        features:
                          type: array
                          items:
                            type: string
                          title: >-
                            list of features compatible with the specified
                            identifier
                      description: >-
                        Version defines the versioning scheme used to negotiate
                        the IBC verison in

                        the connection handshake.
                    description: >-
                      IBC version which can be utilised to determine encodings
                      or protocols for

                      channels or packets utilising this connection.
                  state:
                    description: current state of the connection end.
                    type: string
                    enum:
                      - STATE_UNINITIALIZED_UNSPECIFIED
                      - STATE_INIT
                      - STATE_TRYOPEN
                      - STATE_OPEN
                    default: STATE_UNINITIALIZED_UNSPECIFIED
                  counterparty:
                    description: counterparty chain associated with this connection.
                    type: object
                    properties:
                      client_id:
                        type: string
                        description: >-
                          identifies the client on the counterparty chain
                          associated with a given

                          connection.
                      connection_id:
                        type: string
                        description: >-
                          identifies the connection end on the counterparty
                          chain associated with a

                          given connection.
                      prefix:
                        description: commitment merkle prefix of the counterparty chain.
                        type: object
                        properties:
                          key_prefix:
                            type: string
                            format: byte
                        title: >-
                          MerklePrefix is merkle path prefixed to the key.

                          The constructed key from the Path and the key will be
                          append(Path.KeyPath,

                          append(Path.KeyPrefix, key...))
                  delay_period:
                    type: string
                    format: uint64
                    description: >-
                      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.
                description: >-
                  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.
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            description: >-
              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.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: connection_id
          description: connection unique identifier
          in: path
          required: true
          type: string
      tags:
        - Query
  '/ibc/core/connection/v1/connections/{connection_id}/client_state':
    get:
      summary: |-
        ConnectionClientState queries the client state associated with the
        connection.
      operationId: ConnectionClientState
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              identified_client_state:
                title: client state associated with the channel
                type: object
                properties:
                  client_id:
                    type: string
                    title: client identifier
                  client_state:
                    type: object
                    properties:
                      type_url:
                        type: string
                        description: >-
                          A URL/resource name that uniquely identifies the type
                          of the serialized

                          protocol buffer message. This string must contain at
                          least

                          one "/" character. The last segment of the URL's path
                          must represent

                          the fully qualified name of the type (as in

                          `path/google.protobuf.Duration`). The name should be
                          in a canonical form

                          (e.g., leading "." is not accepted).


                          In practice, teams usually precompile into the binary
                          all types that they

                          expect it to use in the context of Any. However, for
                          URLs which use the

                          scheme `http`, `https`, or no scheme, one can
                          optionally set up a type

                          server that maps type URLs to message definitions as
                          follows:


                          * If no scheme is provided, `https` is assumed.

                          * An HTTP GET on the URL must yield a
                          [google.protobuf.Type][]
                            value in binary format, or produce an error.
                          * Applications are allowed to cache lookup results
                          based on the
                            URL, or have them precompiled into a binary to avoid any
                            lookup. Therefore, binary compatibility needs to be preserved
                            on changes to types. (Use versioned type names to manage
                            breaking changes.)

                          Note: this functionality is not currently available in
                          the official

                          protobuf release, and it is not used for type URLs
                          beginning with

                          type.googleapis.com.


                          Schemes other than `http`, `https` (or the empty
                          scheme) might be

                          used with implementation specific semantics.
                      value:
                        type: string
                        format: byte
                        description: >-
                          Must be a valid serialized protocol buffer of the
                          above specified type.
                    description: >-
                      `Any` contains an arbitrary serialized protocol buffer
                      message along with a

                      URL that describes the type of the serialized message.


                      Protobuf library provides support to pack/unpack Any
                      values in the form

                      of utility functions or additional generated methods of
                      the Any type.


                      Example 1: Pack and unpack a message in C++.

                          Foo foo = ...;
                          Any any;
                          any.PackFrom(foo);
                          ...
                          if (any.UnpackTo(&foo)) {
                            ...
                          }

                      Example 2: Pack and unpack a message in Java.

                          Foo foo = ...;
                          Any any = Any.pack(foo);
                          ...
                          if (any.is(Foo.class)) {
                            foo = any.unpack(Foo.class);
                          }

                       Example 3: Pack and unpack a message in Python.

                          foo = Foo(...)
                          any = Any()
                          any.Pack(foo)
                          ...
                          if any.Is(Foo.DESCRIPTOR):
                            any.Unpack(foo)
                            ...

                       Example 4: Pack and unpack a message in Go

                           foo := &pb.Foo{...}
                           any, err := ptypes.MarshalAny(foo)
                           ...
                           foo := &pb.Foo{}
                           if err := ptypes.UnmarshalAny(any, foo); err != nil {
                             ...
                           }

                      The pack methods provided by protobuf library will by
                      default use

                      'type.googleapis.com/full.type.name' as the type URL and
                      the unpack

                      methods only use the fully qualified type name after the
                      last '/'

                      in the type URL, for example "foo.bar.com/x/y.z" will
                      yield type

                      name "y.z".



                      JSON

                      ====

                      The JSON representation of an `Any` value uses the regular

                      representation of the deserialized, embedded message, with
                      an

                      additional field `@type` which contains the type URL.
                      Example:

                          package google.profile;
                          message Person {
                            string first_name = 1;
                            string last_name = 2;
                          }

                          {
                            "@type": "type.googleapis.com/google.profile.Person",
                            "firstName": <string>,
                            "lastName": <string>
                          }

                      If the embedded message type is well-known and has a
                      custom JSON

                      representation, that representation will be embedded
                      adding a field

                      `value` which holds the custom JSON in addition to the
                      `@type`

                      field. Example (for message [google.protobuf.Duration][]):

                          {
                            "@type": "type.googleapis.com/google.protobuf.Duration",
                            "value": "1.212s"
                          }
                    title: client state
                description: >-
                  IdentifiedClientState defines a client state with an
                  additional client

                  identifier field.
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QueryConnectionClientStateResponse is the response type for the
              Query/ConnectionClientState RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: connection_id
          description: connection identifier
          in: path
          required: true
          type: string
      tags:
        - Query
  '/ibc/core/connection/v1/connections/{connection_id}/consensus_state/revision/{revision_number}/height/{revision_height}':
    get:
      summary: |-
        ConnectionConsensusState queries the consensus state associated with the
        connection.
      operationId: ConnectionConsensusState
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              consensus_state:
                type: object
                properties:
                  type_url:
                    type: string
                    description: >-
                      A URL/resource name that uniquely identifies the type of
                      the serialized

                      protocol buffer message. This string must contain at least

                      one "/" character. The last segment of the URL's path must
                      represent

                      the fully qualified name of the type (as in

                      `path/google.protobuf.Duration`). The name should be in a
                      canonical form

                      (e.g., leading "." is not accepted).


                      In practice, teams usually precompile into the binary all
                      types that they

                      expect it to use in the context of Any. However, for URLs
                      which use the

                      scheme `http`, `https`, or no scheme, one can optionally
                      set up a type

                      server that maps type URLs to message definitions as
                      follows:


                      * If no scheme is provided, `https` is assumed.

                      * An HTTP GET on the URL must yield a
                      [google.protobuf.Type][]
                        value in binary format, or produce an error.
                      * Applications are allowed to cache lookup results based
                      on the
                        URL, or have them precompiled into a binary to avoid any
                        lookup. Therefore, binary compatibility needs to be preserved
                        on changes to types. (Use versioned type names to manage
                        breaking changes.)

                      Note: this functionality is not currently available in the
                      official

                      protobuf release, and it is not used for type URLs
                      beginning with

                      type.googleapis.com.


                      Schemes other than `http`, `https` (or the empty scheme)
                      might be

                      used with implementation specific semantics.
                  value:
                    type: string
                    format: byte
                    description: >-
                      Must be a valid serialized protocol buffer of the above
                      specified type.
                description: >-
                  `Any` contains an arbitrary serialized protocol buffer message
                  along with a

                  URL that describes the type of the serialized message.


                  Protobuf library provides support to pack/unpack Any values in
                  the form

                  of utility functions or additional generated methods of the
                  Any type.


                  Example 1: Pack and unpack a message in C++.

                      Foo foo = ...;
                      Any any;
                      any.PackFrom(foo);
                      ...
                      if (any.UnpackTo(&foo)) {
                        ...
                      }

                  Example 2: Pack and unpack a message in Java.

                      Foo foo = ...;
                      Any any = Any.pack(foo);
                      ...
                      if (any.is(Foo.class)) {
                        foo = any.unpack(Foo.class);
                      }

                   Example 3: Pack and unpack a message in Python.

                      foo = Foo(...)
                      any = Any()
                      any.Pack(foo)
                      ...
                      if any.Is(Foo.DESCRIPTOR):
                        any.Unpack(foo)
                        ...

                   Example 4: Pack and unpack a message in Go

                       foo := &pb.Foo{...}
                       any, err := ptypes.MarshalAny(foo)
                       ...
                       foo := &pb.Foo{}
                       if err := ptypes.UnmarshalAny(any, foo); err != nil {
                         ...
                       }

                  The pack methods provided by protobuf library will by default
                  use

                  'type.googleapis.com/full.type.name' as the type URL and the
                  unpack

                  methods only use the fully qualified type name after the last
                  '/'

                  in the type URL, for example "foo.bar.com/x/y.z" will yield
                  type

                  name "y.z".



                  JSON

                  ====

                  The JSON representation of an `Any` value uses the regular

                  representation of the deserialized, embedded message, with an

                  additional field `@type` which contains the type URL. Example:

                      package google.profile;
                      message Person {
                        string first_name = 1;
                        string last_name = 2;
                      }

                      {
                        "@type": "type.googleapis.com/google.profile.Person",
                        "firstName": <string>,
                        "lastName": <string>
                      }

                  If the embedded message type is well-known and has a custom
                  JSON

                  representation, that representation will be embedded adding a
                  field

                  `value` which holds the custom JSON in addition to the `@type`

                  field. Example (for message [google.protobuf.Duration][]):

                      {
                        "@type": "type.googleapis.com/google.protobuf.Duration",
                        "value": "1.212s"
                      }
                title: consensus state associated with the channel
              client_id:
                type: string
                title: client ID associated with the consensus state
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QueryConnectionConsensusStateResponse is the response type for the
              Query/ConnectionConsensusState RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: connection_id
          description: connection identifier
          in: path
          required: true
          type: string
        - name: revision_number
          in: path
          required: true
          type: string
          format: uint64
        - name: revision_height
          in: path
          required: true
          type: string
          format: uint64
      tags:
        - Query
  /ibc/core/channel/v1/channels:
    get:
      summary: Channels queries all the IBC channels of a chain.
      operationId: Channels
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              channels:
                type: array
                items:
                  type: object
                  properties:
                    state:
                      title: current state of the channel end
                      type: string
                      enum:
                        - STATE_UNINITIALIZED_UNSPECIFIED
                        - STATE_INIT
                        - STATE_TRYOPEN
                        - STATE_OPEN
                        - STATE_CLOSED
                      default: STATE_UNINITIALIZED_UNSPECIFIED
                      description: >-
                        State defines if a channel is in one of the following
                        states:

                        CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.

                         - STATE_UNINITIALIZED_UNSPECIFIED: Default State
                         - STATE_INIT: A channel has just started the opening handshake.
                         - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.
                         - STATE_OPEN: A channel has completed the handshake. Open channels are
                        ready to send and receive packets.
                         - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive
                        packets.
                    ordering:
                      title: whether the channel is ordered or unordered
                      type: string
                      enum:
                        - ORDER_NONE_UNSPECIFIED
                        - ORDER_UNORDERED
                        - ORDER_ORDERED
                      default: ORDER_NONE_UNSPECIFIED
                      description: >-
                        - ORDER_NONE_UNSPECIFIED: zero-value for channel
                        ordering
                         - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in
                        which they were sent.
                         - ORDER_ORDERED: packets are delivered exactly in the order which they were sent
                    counterparty:
                      title: counterparty channel end
                      type: object
                      properties:
                        port_id:
                          type: string
                          description: >-
                            port on the counterparty chain which owns the other
                            end of the channel.
                        channel_id:
                          type: string
                          title: channel end on the counterparty chain
                    connection_hops:
                      type: array
                      items:
                        type: string
                      title: >-
                        list of connection identifiers, in order, along which
                        packets sent on

                        this channel will travel
                    version:
                      type: string
                      title: >-
                        opaque channel version, which is agreed upon during the
                        handshake
                    port_id:
                      type: string
                      title: port identifier
                    channel_id:
                      type: string
                      title: channel identifier
                  description: >-
                    IdentifiedChannel defines a channel with additional port and
                    channel

                    identifier fields.
                description: list of stored channels of the chain.
              pagination:
                title: pagination response
                type: object
                properties:
                  next_key:
                    type: string
                    format: byte
                    title: |-
                      next_key is the key to be passed to PageRequest.key to
                      query the next page most efficiently
                  total:
                    type: string
                    format: uint64
                    title: >-
                      total is total number of results available if
                      PageRequest.count_total

                      was set, its value is undefined otherwise
                description: >-
                  PageResponse is to be embedded in gRPC response messages where
                  the

                  corresponding request message has used PageRequest.

                   message SomeResponse {
                           repeated Bar results = 1;
                           PageResponse page = 2;
                   }
              height:
                title: query block height
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            description: >-
              QueryChannelsResponse is the response type for the Query/Channels
              RPC method.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: pagination.key
          description: |-
            key is a value returned in PageResponse.next_key to begin
            querying the next page most efficiently. Only one of offset or key
            should be set.
          in: query
          required: false
          type: string
          format: byte
        - name: pagination.offset
          description: >-
            offset is a numeric offset that can be used when key is unavailable.

            It is less efficient than using key. Only one of offset or key
            should

            be set.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.limit
          description: >-
            limit is the total number of results to be returned in the result
            page.

            If left empty it will default to a value to be set by each app.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.count_total
          description: >-
            count_total is set to true  to indicate that the result set should
            include

            a count of the total number of items available for pagination in
            UIs.

            count_total is only respected when offset is used. It is ignored
            when key

            is set.
          in: query
          required: false
          type: boolean
          format: boolean
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}':
    get:
      summary: Channel queries an IBC Channel.
      operationId: Channel
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              channel:
                title: channel associated with the request identifiers
                type: object
                properties:
                  state:
                    title: current state of the channel end
                    type: string
                    enum:
                      - STATE_UNINITIALIZED_UNSPECIFIED
                      - STATE_INIT
                      - STATE_TRYOPEN
                      - STATE_OPEN
                      - STATE_CLOSED
                    default: STATE_UNINITIALIZED_UNSPECIFIED
                    description: >-
                      State defines if a channel is in one of the following
                      states:

                      CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.

                       - STATE_UNINITIALIZED_UNSPECIFIED: Default State
                       - STATE_INIT: A channel has just started the opening handshake.
                       - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.
                       - STATE_OPEN: A channel has completed the handshake. Open channels are
                      ready to send and receive packets.
                       - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive
                      packets.
                  ordering:
                    title: whether the channel is ordered or unordered
                    type: string
                    enum:
                      - ORDER_NONE_UNSPECIFIED
                      - ORDER_UNORDERED
                      - ORDER_ORDERED
                    default: ORDER_NONE_UNSPECIFIED
                    description: |-
                      - ORDER_NONE_UNSPECIFIED: zero-value for channel ordering
                       - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in
                      which they were sent.
                       - ORDER_ORDERED: packets are delivered exactly in the order which they were sent
                  counterparty:
                    title: counterparty channel end
                    type: object
                    properties:
                      port_id:
                        type: string
                        description: >-
                          port on the counterparty chain which owns the other
                          end of the channel.
                      channel_id:
                        type: string
                        title: channel end on the counterparty chain
                  connection_hops:
                    type: array
                    items:
                      type: string
                    title: >-
                      list of connection identifiers, in order, along which
                      packets sent on

                      this channel will travel
                  version:
                    type: string
                    title: >-
                      opaque channel version, which is agreed upon during the
                      handshake
                description: >-
                  Channel defines pipeline for exactly-once packet delivery
                  between specific

                  modules on separate blockchains, which has at least one end
                  capable of

                  sending packets and one end capable of receiving packets.
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            description: >-
              QueryChannelResponse is the response type for the Query/Channel
              RPC method.

              Besides the Channel end, it includes a proof and the height from
              which the

              proof was retrieved.
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/client_state':
    get:
      summary: >-
        ChannelClientState queries for the client state for the channel
        associated

        with the provided channel identifiers.
      operationId: ChannelClientState
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              identified_client_state:
                title: client state associated with the channel
                type: object
                properties:
                  client_id:
                    type: string
                    title: client identifier
                  client_state:
                    type: object
                    properties:
                      type_url:
                        type: string
                        description: >-
                          A URL/resource name that uniquely identifies the type
                          of the serialized

                          protocol buffer message. This string must contain at
                          least

                          one "/" character. The last segment of the URL's path
                          must represent

                          the fully qualified name of the type (as in

                          `path/google.protobuf.Duration`). The name should be
                          in a canonical form

                          (e.g., leading "." is not accepted).


                          In practice, teams usually precompile into the binary
                          all types that they

                          expect it to use in the context of Any. However, for
                          URLs which use the

                          scheme `http`, `https`, or no scheme, one can
                          optionally set up a type

                          server that maps type URLs to message definitions as
                          follows:


                          * If no scheme is provided, `https` is assumed.

                          * An HTTP GET on the URL must yield a
                          [google.protobuf.Type][]
                            value in binary format, or produce an error.
                          * Applications are allowed to cache lookup results
                          based on the
                            URL, or have them precompiled into a binary to avoid any
                            lookup. Therefore, binary compatibility needs to be preserved
                            on changes to types. (Use versioned type names to manage
                            breaking changes.)

                          Note: this functionality is not currently available in
                          the official

                          protobuf release, and it is not used for type URLs
                          beginning with

                          type.googleapis.com.


                          Schemes other than `http`, `https` (or the empty
                          scheme) might be

                          used with implementation specific semantics.
                      value:
                        type: string
                        format: byte
                        description: >-
                          Must be a valid serialized protocol buffer of the
                          above specified type.
                    description: >-
                      `Any` contains an arbitrary serialized protocol buffer
                      message along with a

                      URL that describes the type of the serialized message.


                      Protobuf library provides support to pack/unpack Any
                      values in the form

                      of utility functions or additional generated methods of
                      the Any type.


                      Example 1: Pack and unpack a message in C++.

                          Foo foo = ...;
                          Any any;
                          any.PackFrom(foo);
                          ...
                          if (any.UnpackTo(&foo)) {
                            ...
                          }

                      Example 2: Pack and unpack a message in Java.

                          Foo foo = ...;
                          Any any = Any.pack(foo);
                          ...
                          if (any.is(Foo.class)) {
                            foo = any.unpack(Foo.class);
                          }

                       Example 3: Pack and unpack a message in Python.

                          foo = Foo(...)
                          any = Any()
                          any.Pack(foo)
                          ...
                          if any.Is(Foo.DESCRIPTOR):
                            any.Unpack(foo)
                            ...

                       Example 4: Pack and unpack a message in Go

                           foo := &pb.Foo{...}
                           any, err := ptypes.MarshalAny(foo)
                           ...
                           foo := &pb.Foo{}
                           if err := ptypes.UnmarshalAny(any, foo); err != nil {
                             ...
                           }

                      The pack methods provided by protobuf library will by
                      default use

                      'type.googleapis.com/full.type.name' as the type URL and
                      the unpack

                      methods only use the fully qualified type name after the
                      last '/'

                      in the type URL, for example "foo.bar.com/x/y.z" will
                      yield type

                      name "y.z".



                      JSON

                      ====

                      The JSON representation of an `Any` value uses the regular

                      representation of the deserialized, embedded message, with
                      an

                      additional field `@type` which contains the type URL.
                      Example:

                          package google.profile;
                          message Person {
                            string first_name = 1;
                            string last_name = 2;
                          }

                          {
                            "@type": "type.googleapis.com/google.profile.Person",
                            "firstName": <string>,
                            "lastName": <string>
                          }

                      If the embedded message type is well-known and has a
                      custom JSON

                      representation, that representation will be embedded
                      adding a field

                      `value` which holds the custom JSON in addition to the
                      `@type`

                      field. Example (for message [google.protobuf.Duration][]):

                          {
                            "@type": "type.googleapis.com/google.protobuf.Duration",
                            "value": "1.212s"
                          }
                    title: client state
                description: >-
                  IdentifiedClientState defines a client state with an
                  additional client

                  identifier field.
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QueryChannelClientStateResponse is the Response type for the
              Query/QueryChannelClientState RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/consensus_state/revision/{revision_number}/height/{revision_height}':
    get:
      summary: |-
        ChannelConsensusState queries for the consensus state for the channel
        associated with the provided channel identifiers.
      operationId: ChannelConsensusState
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              consensus_state:
                type: object
                properties:
                  type_url:
                    type: string
                    description: >-
                      A URL/resource name that uniquely identifies the type of
                      the serialized

                      protocol buffer message. This string must contain at least

                      one "/" character. The last segment of the URL's path must
                      represent

                      the fully qualified name of the type (as in

                      `path/google.protobuf.Duration`). The name should be in a
                      canonical form

                      (e.g., leading "." is not accepted).


                      In practice, teams usually precompile into the binary all
                      types that they

                      expect it to use in the context of Any. However, for URLs
                      which use the

                      scheme `http`, `https`, or no scheme, one can optionally
                      set up a type

                      server that maps type URLs to message definitions as
                      follows:


                      * If no scheme is provided, `https` is assumed.

                      * An HTTP GET on the URL must yield a
                      [google.protobuf.Type][]
                        value in binary format, or produce an error.
                      * Applications are allowed to cache lookup results based
                      on the
                        URL, or have them precompiled into a binary to avoid any
                        lookup. Therefore, binary compatibility needs to be preserved
                        on changes to types. (Use versioned type names to manage
                        breaking changes.)

                      Note: this functionality is not currently available in the
                      official

                      protobuf release, and it is not used for type URLs
                      beginning with

                      type.googleapis.com.


                      Schemes other than `http`, `https` (or the empty scheme)
                      might be

                      used with implementation specific semantics.
                  value:
                    type: string
                    format: byte
                    description: >-
                      Must be a valid serialized protocol buffer of the above
                      specified type.
                description: >-
                  `Any` contains an arbitrary serialized protocol buffer message
                  along with a

                  URL that describes the type of the serialized message.


                  Protobuf library provides support to pack/unpack Any values in
                  the form

                  of utility functions or additional generated methods of the
                  Any type.


                  Example 1: Pack and unpack a message in C++.

                      Foo foo = ...;
                      Any any;
                      any.PackFrom(foo);
                      ...
                      if (any.UnpackTo(&foo)) {
                        ...
                      }

                  Example 2: Pack and unpack a message in Java.

                      Foo foo = ...;
                      Any any = Any.pack(foo);
                      ...
                      if (any.is(Foo.class)) {
                        foo = any.unpack(Foo.class);
                      }

                   Example 3: Pack and unpack a message in Python.

                      foo = Foo(...)
                      any = Any()
                      any.Pack(foo)
                      ...
                      if any.Is(Foo.DESCRIPTOR):
                        any.Unpack(foo)
                        ...

                   Example 4: Pack and unpack a message in Go

                       foo := &pb.Foo{...}
                       any, err := ptypes.MarshalAny(foo)
                       ...
                       foo := &pb.Foo{}
                       if err := ptypes.UnmarshalAny(any, foo); err != nil {
                         ...
                       }

                  The pack methods provided by protobuf library will by default
                  use

                  'type.googleapis.com/full.type.name' as the type URL and the
                  unpack

                  methods only use the fully qualified type name after the last
                  '/'

                  in the type URL, for example "foo.bar.com/x/y.z" will yield
                  type

                  name "y.z".



                  JSON

                  ====

                  The JSON representation of an `Any` value uses the regular

                  representation of the deserialized, embedded message, with an

                  additional field `@type` which contains the type URL. Example:

                      package google.profile;
                      message Person {
                        string first_name = 1;
                        string last_name = 2;
                      }

                      {
                        "@type": "type.googleapis.com/google.profile.Person",
                        "firstName": <string>,
                        "lastName": <string>
                      }

                  If the embedded message type is well-known and has a custom
                  JSON

                  representation, that representation will be embedded adding a
                  field

                  `value` which holds the custom JSON in addition to the `@type`

                  field. Example (for message [google.protobuf.Duration][]):

                      {
                        "@type": "type.googleapis.com/google.protobuf.Duration",
                        "value": "1.212s"
                      }
                title: consensus state associated with the channel
              client_id:
                type: string
                title: client ID associated with the consensus state
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QueryChannelClientStateResponse is the Response type for the
              Query/QueryChannelClientState RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
        - name: revision_number
          description: revision number of the consensus state
          in: path
          required: true
          type: string
          format: uint64
        - name: revision_height
          description: revision height of the consensus state
          in: path
          required: true
          type: string
          format: uint64
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/next_sequence':
    get:
      summary: >-
        NextSequenceReceive returns the next receive sequence for a given
        channel.
      operationId: NextSequenceReceive
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              next_sequence_receive:
                type: string
                format: uint64
                title: next sequence receive number
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QuerySequenceResponse is the request type for the
              Query/QueryNextSequenceReceiveResponse RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acknowledgements':
    get:
      summary: >-
        PacketAcknowledgements returns all the packet acknowledgements
        associated

        with a channel.
      operationId: PacketAcknowledgements
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              acknowledgements:
                type: array
                items:
                  type: object
                  properties:
                    port_id:
                      type: string
                      description: channel port identifier.
                    channel_id:
                      type: string
                      description: channel unique identifier.
                    sequence:
                      type: string
                      format: uint64
                      description: packet sequence.
                    data:
                      type: string
                      format: byte
                      description: embedded data that represents packet state.
                  description: >-
                    PacketState defines the generic type necessary to retrieve
                    and store

                    packet commitments, acknowledgements, and receipts.

                    Caller is responsible for knowing the context necessary to
                    interpret this

                    state as a commitment, acknowledgement, or a receipt.
              pagination:
                title: pagination response
                type: object
                properties:
                  next_key:
                    type: string
                    format: byte
                    title: |-
                      next_key is the key to be passed to PageRequest.key to
                      query the next page most efficiently
                  total:
                    type: string
                    format: uint64
                    title: >-
                      total is total number of results available if
                      PageRequest.count_total

                      was set, its value is undefined otherwise
                description: >-
                  PageResponse is to be embedded in gRPC response messages where
                  the

                  corresponding request message has used PageRequest.

                   message SomeResponse {
                           repeated Bar results = 1;
                           PageResponse page = 2;
                   }
              height:
                title: query block height
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QueryPacketAcknowledgemetsResponse is the request type for the
              Query/QueryPacketAcknowledgements RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
        - name: pagination.key
          description: |-
            key is a value returned in PageResponse.next_key to begin
            querying the next page most efficiently. Only one of offset or key
            should be set.
          in: query
          required: false
          type: string
          format: byte
        - name: pagination.offset
          description: >-
            offset is a numeric offset that can be used when key is unavailable.

            It is less efficient than using key. Only one of offset or key
            should

            be set.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.limit
          description: >-
            limit is the total number of results to be returned in the result
            page.

            If left empty it will default to a value to be set by each app.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.count_total
          description: >-
            count_total is set to true  to indicate that the result set should
            include

            a count of the total number of items available for pagination in
            UIs.

            count_total is only respected when offset is used. It is ignored
            when key

            is set.
          in: query
          required: false
          type: boolean
          format: boolean
        - name: packet_commitment_sequences
          description: list of packet sequences.
          in: query
          required: false
          type: array
          items:
            type: string
            format: uint64
          collectionFormat: multi
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}':
    get:
      summary: PacketAcknowledgement queries a stored packet acknowledgement hash.
      operationId: PacketAcknowledgement
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              acknowledgement:
                type: string
                format: byte
                title: packet associated with the request fields
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: >-
              QueryPacketAcknowledgementResponse defines the client query
              response for a

              packet which also includes a proof and the height from which the

              proof was retrieved
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
        - name: sequence
          description: packet sequence
          in: path
          required: true
          type: string
          format: uint64
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments':
    get:
      summary: |-
        PacketCommitments returns all the packet commitments hashes associated
        with a channel.
      operationId: PacketCommitments
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              commitments:
                type: array
                items:
                  type: object
                  properties:
                    port_id:
                      type: string
                      description: channel port identifier.
                    channel_id:
                      type: string
                      description: channel unique identifier.
                    sequence:
                      type: string
                      format: uint64
                      description: packet sequence.
                    data:
                      type: string
                      format: byte
                      description: embedded data that represents packet state.
                  description: >-
                    PacketState defines the generic type necessary to retrieve
                    and store

                    packet commitments, acknowledgements, and receipts.

                    Caller is responsible for knowing the context necessary to
                    interpret this

                    state as a commitment, acknowledgement, or a receipt.
              pagination:
                title: pagination response
                type: object
                properties:
                  next_key:
                    type: string
                    format: byte
                    title: |-
                      next_key is the key to be passed to PageRequest.key to
                      query the next page most efficiently
                  total:
                    type: string
                    format: uint64
                    title: >-
                      total is total number of results available if
                      PageRequest.count_total

                      was set, its value is undefined otherwise
                description: >-
                  PageResponse is to be embedded in gRPC response messages where
                  the

                  corresponding request message has used PageRequest.

                   message SomeResponse {
                           repeated Bar results = 1;
                           PageResponse page = 2;
                   }
              height:
                title: query block height
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QueryPacketCommitmentsResponse is the request type for the
              Query/QueryPacketCommitments RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
        - name: pagination.key
          description: |-
            key is a value returned in PageResponse.next_key to begin
            querying the next page most efficiently. Only one of offset or key
            should be set.
          in: query
          required: false
          type: string
          format: byte
        - name: pagination.offset
          description: >-
            offset is a numeric offset that can be used when key is unavailable.

            It is less efficient than using key. Only one of offset or key
            should

            be set.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.limit
          description: >-
            limit is the total number of results to be returned in the result
            page.

            If left empty it will default to a value to be set by each app.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.count_total
          description: >-
            count_total is set to true  to indicate that the result set should
            include

            a count of the total number of items available for pagination in
            UIs.

            count_total is only respected when offset is used. It is ignored
            when key

            is set.
          in: query
          required: false
          type: boolean
          format: boolean
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_ack_sequences}/unreceived_acks':
    get:
      summary: >-
        UnreceivedAcks returns all the unreceived IBC acknowledgements
        associated

        with a channel and sequences.
      operationId: UnreceivedAcks
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              sequences:
                type: array
                items:
                  type: string
                  format: uint64
                title: list of unreceived acknowledgement sequences
              height:
                title: query block height
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QueryUnreceivedAcksResponse is the response type for the
              Query/UnreceivedAcks RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
        - name: packet_ack_sequences
          description: list of acknowledgement sequences
          in: path
          required: true
          type: array
          items:
            type: string
            format: uint64
          collectionFormat: csv
          minItems: 1
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/unreceived_packets':
    get:
      summary: >-
        UnreceivedPackets returns all the unreceived IBC packets associated with
        a

        channel and sequences.
      operationId: UnreceivedPackets
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              sequences:
                type: array
                items:
                  type: string
                  format: uint64
                title: list of unreceived packet sequences
              height:
                title: query block height
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QueryUnreceivedPacketsResponse is the response type for the
              Query/UnreceivedPacketCommitments RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
        - name: packet_commitment_sequences
          description: list of packet sequences
          in: path
          required: true
          type: array
          items:
            type: string
            format: uint64
          collectionFormat: csv
          minItems: 1
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}':
    get:
      summary: PacketCommitment queries a stored packet commitment hash.
      operationId: PacketCommitment
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              commitment:
                type: string
                format: byte
                title: packet associated with the request fields
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: >-
              QueryPacketCommitmentResponse defines the client query response
              for a packet

              which also includes a proof and the height from which the proof
              was

              retrieved
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
        - name: sequence
          description: packet sequence
          in: path
          required: true
          type: string
          format: uint64
      tags:
        - Query
  '/ibc/core/channel/v1/channels/{channel_id}/ports/{port_id}/packet_receipts/{sequence}':
    get:
      summary: >-
        PacketReceipt queries if a given packet sequence has been received on
        the

        queried chain
      operationId: PacketReceipt
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              received:
                type: boolean
                format: boolean
                title: success flag for if receipt exists
              proof:
                type: string
                format: byte
                title: merkle proof of existence
              proof_height:
                title: height at which the proof was retrieved
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: >-
              QueryPacketReceiptResponse defines the client query response for a
              packet

              receipt which also includes a proof, and the height from which the
              proof was

              retrieved
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: channel_id
          description: channel unique identifier
          in: path
          required: true
          type: string
        - name: port_id
          description: port unique identifier
          in: path
          required: true
          type: string
        - name: sequence
          description: packet sequence
          in: path
          required: true
          type: string
          format: uint64
      tags:
        - Query
  '/ibc/core/channel/v1/connections/{connection}/channels':
    get:
      summary: |-
        ConnectionChannels queries all the channels associated with a connection
        end.
      operationId: ConnectionChannels
      responses:
        '200':
          description: A successful response.
          schema:
            type: object
            properties:
              channels:
                type: array
                items:
                  type: object
                  properties:
                    state:
                      title: current state of the channel end
                      type: string
                      enum:
                        - STATE_UNINITIALIZED_UNSPECIFIED
                        - STATE_INIT
                        - STATE_TRYOPEN
                        - STATE_OPEN
                        - STATE_CLOSED
                      default: STATE_UNINITIALIZED_UNSPECIFIED
                      description: >-
                        State defines if a channel is in one of the following
                        states:

                        CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.

                         - STATE_UNINITIALIZED_UNSPECIFIED: Default State
                         - STATE_INIT: A channel has just started the opening handshake.
                         - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.
                         - STATE_OPEN: A channel has completed the handshake. Open channels are
                        ready to send and receive packets.
                         - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive
                        packets.
                    ordering:
                      title: whether the channel is ordered or unordered
                      type: string
                      enum:
                        - ORDER_NONE_UNSPECIFIED
                        - ORDER_UNORDERED
                        - ORDER_ORDERED
                      default: ORDER_NONE_UNSPECIFIED
                      description: >-
                        - ORDER_NONE_UNSPECIFIED: zero-value for channel
                        ordering
                         - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in
                        which they were sent.
                         - ORDER_ORDERED: packets are delivered exactly in the order which they were sent
                    counterparty:
                      title: counterparty channel end
                      type: object
                      properties:
                        port_id:
                          type: string
                          description: >-
                            port on the counterparty chain which owns the other
                            end of the channel.
                        channel_id:
                          type: string
                          title: channel end on the counterparty chain
                    connection_hops:
                      type: array
                      items:
                        type: string
                      title: >-
                        list of connection identifiers, in order, along which
                        packets sent on

                        this channel will travel
                    version:
                      type: string
                      title: >-
                        opaque channel version, which is agreed upon during the
                        handshake
                    port_id:
                      type: string
                      title: port identifier
                    channel_id:
                      type: string
                      title: channel identifier
                  description: >-
                    IdentifiedChannel defines a channel with additional port and
                    channel

                    identifier fields.
                description: list of channels associated with a connection.
              pagination:
                title: pagination response
                type: object
                properties:
                  next_key:
                    type: string
                    format: byte
                    title: |-
                      next_key is the key to be passed to PageRequest.key to
                      query the next page most efficiently
                  total:
                    type: string
                    format: uint64
                    title: >-
                      total is total number of results available if
                      PageRequest.count_total

                      was set, its value is undefined otherwise
                description: >-
                  PageResponse is to be embedded in gRPC response messages where
                  the

                  corresponding request message has used PageRequest.

                   message SomeResponse {
                           repeated Bar results = 1;
                           PageResponse page = 2;
                   }
              height:
                title: query block height
                type: object
                properties:
                  revision_number:
                    type: string
                    format: uint64
                    title: the revision that the client is currently on
                  revision_height:
                    type: string
                    format: uint64
                    title: the height within the given revision
                description: >-
                  Normally the RevisionHeight is incremented at each height
                  while keeping

                  RevisionNumber the same. However some consensus algorithms may
                  choose to

                  reset the height in certain conditions e.g. hard forks,
                  state-machine

                  breaking changes In these cases, the RevisionNumber is
                  incremented so that

                  height continues to be monitonically increasing even as the
                  RevisionHeight

                  gets reset
            title: |-
              QueryConnectionChannelsResponse is the Response type for the
              Query/QueryConnectionChannels RPC method
        default:
          description: An unexpected error response
          schema:
            type: object
            properties:
              error:
                type: string
              code:
                type: integer
                format: int32
              message:
                type: string
              details:
                type: array
                items:
                  type: object
                  properties:
                    type_url:
                      type: string
                      description: >-
                        A URL/resource name that uniquely identifies the type of
                        the serialized

                        protocol buffer message. This string must contain at
                        least

                        one "/" character. The last segment of the URL's path
                        must represent

                        the fully qualified name of the type (as in

                        `path/google.protobuf.Duration`). The name should be in
                        a canonical form

                        (e.g., leading "." is not accepted).


                        In practice, teams usually precompile into the binary
                        all types that they

                        expect it to use in the context of Any. However, for
                        URLs which use the

                        scheme `http`, `https`, or no scheme, one can optionally
                        set up a type

                        server that maps type URLs to message definitions as
                        follows:


                        * If no scheme is provided, `https` is assumed.

                        * An HTTP GET on the URL must yield a
                        [google.protobuf.Type][]
                          value in binary format, or produce an error.
                        * Applications are allowed to cache lookup results based
                        on the
                          URL, or have them precompiled into a binary to avoid any
                          lookup. Therefore, binary compatibility needs to be preserved
                          on changes to types. (Use versioned type names to manage
                          breaking changes.)

                        Note: this functionality is not currently available in
                        the official

                        protobuf release, and it is not used for type URLs
                        beginning with

                        type.googleapis.com.


                        Schemes other than `http`, `https` (or the empty scheme)
                        might be

                        used with implementation specific semantics.
                    value:
                      type: string
                      format: byte
                      description: >-
                        Must be a valid serialized protocol buffer of the above
                        specified type.
                  description: >-
                    `Any` contains an arbitrary serialized protocol buffer
                    message along with a

                    URL that describes the type of the serialized message.


                    Protobuf library provides support to pack/unpack Any values
                    in the form

                    of utility functions or additional generated methods of the
                    Any type.


                    Example 1: Pack and unpack a message in C++.

                        Foo foo = ...;
                        Any any;
                        any.PackFrom(foo);
                        ...
                        if (any.UnpackTo(&foo)) {
                          ...
                        }

                    Example 2: Pack and unpack a message in Java.

                        Foo foo = ...;
                        Any any = Any.pack(foo);
                        ...
                        if (any.is(Foo.class)) {
                          foo = any.unpack(Foo.class);
                        }

                     Example 3: Pack and unpack a message in Python.

                        foo = Foo(...)
                        any = Any()
                        any.Pack(foo)
                        ...
                        if any.Is(Foo.DESCRIPTOR):
                          any.Unpack(foo)
                          ...

                     Example 4: Pack and unpack a message in Go

                         foo := &pb.Foo{...}
                         any, err := ptypes.MarshalAny(foo)
                         ...
                         foo := &pb.Foo{}
                         if err := ptypes.UnmarshalAny(any, foo); err != nil {
                           ...
                         }

                    The pack methods provided by protobuf library will by
                    default use

                    'type.googleapis.com/full.type.name' as the type URL and the
                    unpack

                    methods only use the fully qualified type name after the
                    last '/'

                    in the type URL, for example "foo.bar.com/x/y.z" will yield
                    type

                    name "y.z".



                    JSON

                    ====

                    The JSON representation of an `Any` value uses the regular

                    representation of the deserialized, embedded message, with
                    an

                    additional field `@type` which contains the type URL.
                    Example:

                        package google.profile;
                        message Person {
                          string first_name = 1;
                          string last_name = 2;
                        }

                        {
                          "@type": "type.googleapis.com/google.profile.Person",
                          "firstName": <string>,
                          "lastName": <string>
                        }

                    If the embedded message type is well-known and has a custom
                    JSON

                    representation, that representation will be embedded adding
                    a field

                    `value` which holds the custom JSON in addition to the
                    `@type`

                    field. Example (for message [google.protobuf.Duration][]):

                        {
                          "@type": "type.googleapis.com/google.protobuf.Duration",
                          "value": "1.212s"
                        }
      parameters:
        - name: connection
          description: connection unique identifier
          in: path
          required: true
          type: string
        - name: pagination.key
          description: |-
            key is a value returned in PageResponse.next_key to begin
            querying the next page most efficiently. Only one of offset or key
            should be set.
          in: query
          required: false
          type: string
          format: byte
        - name: pagination.offset
          description: >-
            offset is a numeric offset that can be used when key is unavailable.

            It is less efficient than using key. Only one of offset or key
            should

            be set.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.limit
          description: >-
            limit is the total number of results to be returned in the result
            page.

            If left empty it will default to a value to be set by each app.
          in: query
          required: false
          type: string
          format: uint64
        - name: pagination.count_total
          description: >-
            count_total is set to true  to indicate that the result set should
            include

            a count of the total number of items available for pagination in
            UIs.

            count_total is only respected when offset is used. It is ignored
            when key

            is set.
          in: query
          required: false
          type: boolean
          format: boolean
      tags:
        - Query
definitions:
  cosmos.base.query.v1beta1.PageRequest:
    type: object
    properties:
      key:
        type: string
        format: byte
        description: |-
          key is a value returned in PageResponse.next_key to begin
          querying the next page most efficiently. Only one of offset or key
          should be set.
      offset:
        type: string
        format: uint64
        description: |-
          offset is a numeric offset that can be used when key is unavailable.
          It is less efficient than using key. Only one of offset or key should
          be set.
      limit:
        type: string
        format: uint64
        description: >-
          limit is the total number of results to be returned in the result
          page.

          If left empty it will default to a value to be set by each app.
      count_total:
        type: boolean
        format: boolean
        description: >-
          count_total is set to true  to indicate that the result set should
          include

          a count of the total number of items available for pagination in UIs.

          count_total is only respected when offset is used. It is ignored when
          key

          is set.
    description: |-
      message SomeRequest {
               Foo some_parameter = 1;
               PageRequest pagination = 2;
       }
    title: |-
      PageRequest is to be embedded in gRPC request messages for efficient
      pagination. Ex:
  cosmos.base.query.v1beta1.PageResponse:
    type: object
    properties:
      next_key:
        type: string
        format: byte
        title: |-
          next_key is the key to be passed to PageRequest.key to
          query the next page most efficiently
      total:
        type: string
        format: uint64
        title: |-
          total is total number of results available if PageRequest.count_total
          was set, its value is undefined otherwise
    description: |-
      PageResponse is to be embedded in gRPC response messages where the
      corresponding request message has used PageRequest.

       message SomeResponse {
               repeated Bar results = 1;
               PageResponse page = 2;
       }
  google.protobuf.Any:
    type: object
    properties:
      type_url:
        type: string
        description: >-
          A URL/resource name that uniquely identifies the type of the
          serialized

          protocol buffer message. This string must contain at least

          one "/" character. The last segment of the URL's path must represent

          the fully qualified name of the type (as in

          `path/google.protobuf.Duration`). The name should be in a canonical
          form

          (e.g., leading "." is not accepted).


          In practice, teams usually precompile into the binary all types that
          they

          expect it to use in the context of Any. However, for URLs which use
          the

          scheme `http`, `https`, or no scheme, one can optionally set up a type

          server that maps type URLs to message definitions as follows:


          * If no scheme is provided, `https` is assumed.

          * An HTTP GET on the URL must yield a [google.protobuf.Type][]
            value in binary format, or produce an error.
          * Applications are allowed to cache lookup results based on the
            URL, or have them precompiled into a binary to avoid any
            lookup. Therefore, binary compatibility needs to be preserved
            on changes to types. (Use versioned type names to manage
            breaking changes.)

          Note: this functionality is not currently available in the official

          protobuf release, and it is not used for type URLs beginning with

          type.googleapis.com.


          Schemes other than `http`, `https` (or the empty scheme) might be

          used with implementation specific semantics.
      value:
        type: string
        format: byte
        description: >-
          Must be a valid serialized protocol buffer of the above specified
          type.
    description: >-
      `Any` contains an arbitrary serialized protocol buffer message along with
      a

      URL that describes the type of the serialized message.


      Protobuf library provides support to pack/unpack Any values in the form

      of utility functions or additional generated methods of the Any type.


      Example 1: Pack and unpack a message in C++.

          Foo foo = ...;
          Any any;
          any.PackFrom(foo);
          ...
          if (any.UnpackTo(&foo)) {
            ...
          }

      Example 2: Pack and unpack a message in Java.

          Foo foo = ...;
          Any any = Any.pack(foo);
          ...
          if (any.is(Foo.class)) {
            foo = any.unpack(Foo.class);
          }

       Example 3: Pack and unpack a message in Python.

          foo = Foo(...)
          any = Any()
          any.Pack(foo)
          ...
          if any.Is(Foo.DESCRIPTOR):
            any.Unpack(foo)
            ...

       Example 4: Pack and unpack a message in Go

           foo := &pb.Foo{...}
           any, err := ptypes.MarshalAny(foo)
           ...
           foo := &pb.Foo{}
           if err := ptypes.UnmarshalAny(any, foo); err != nil {
             ...
           }

      The pack methods provided by protobuf library will by default use

      'type.googleapis.com/full.type.name' as the type URL and the unpack

      methods only use the fully qualified type name after the last '/'

      in the type URL, for example "foo.bar.com/x/y.z" will yield type

      name "y.z".



      JSON

      ====

      The JSON representation of an `Any` value uses the regular

      representation of the deserialized, embedded message, with an

      additional field `@type` which contains the type URL. Example:

          package google.profile;
          message Person {
            string first_name = 1;
            string last_name = 2;
          }

          {
            "@type": "type.googleapis.com/google.profile.Person",
            "firstName": <string>,
            "lastName": <string>
          }

      If the embedded message type is well-known and has a custom JSON

      representation, that representation will be embedded adding a field

      `value` which holds the custom JSON in addition to the `@type`

      field. Example (for message [google.protobuf.Duration][]):

          {
            "@type": "type.googleapis.com/google.protobuf.Duration",
            "value": "1.212s"
          }
  grpc.gateway.runtime.Error:
    type: object
    properties:
      error:
        type: string
      code:
        type: integer
        format: int32
      message:
        type: string
      details:
        type: array
        items:
          type: object
          properties:
            type_url:
              type: string
              description: >-
                A URL/resource name that uniquely identifies the type of the
                serialized

                protocol buffer message. This string must contain at least

                one "/" character. The last segment of the URL's path must
                represent

                the fully qualified name of the type (as in

                `path/google.protobuf.Duration`). The name should be in a
                canonical form

                (e.g., leading "." is not accepted).


                In practice, teams usually precompile into the binary all types
                that they

                expect it to use in the context of Any. However, for URLs which
                use the

                scheme `http`, `https`, or no scheme, one can optionally set up
                a type

                server that maps type URLs to message definitions as follows:


                * If no scheme is provided, `https` is assumed.

                * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                  value in binary format, or produce an error.
                * Applications are allowed to cache lookup results based on the
                  URL, or have them precompiled into a binary to avoid any
                  lookup. Therefore, binary compatibility needs to be preserved
                  on changes to types. (Use versioned type names to manage
                  breaking changes.)

                Note: this functionality is not currently available in the
                official

                protobuf release, and it is not used for type URLs beginning
                with

                type.googleapis.com.


                Schemes other than `http`, `https` (or the empty scheme) might
                be

                used with implementation specific semantics.
            value:
              type: string
              format: byte
              description: >-
                Must be a valid serialized protocol buffer of the above
                specified type.
          description: >-
            `Any` contains an arbitrary serialized protocol buffer message along
            with a

            URL that describes the type of the serialized message.


            Protobuf library provides support to pack/unpack Any values in the
            form

            of utility functions or additional generated methods of the Any
            type.


            Example 1: Pack and unpack a message in C++.

                Foo foo = ...;
                Any any;
                any.PackFrom(foo);
                ...
                if (any.UnpackTo(&foo)) {
                  ...
                }

            Example 2: Pack and unpack a message in Java.

                Foo foo = ...;
                Any any = Any.pack(foo);
                ...
                if (any.is(Foo.class)) {
                  foo = any.unpack(Foo.class);
                }

             Example 3: Pack and unpack a message in Python.

                foo = Foo(...)
                any = Any()
                any.Pack(foo)
                ...
                if any.Is(Foo.DESCRIPTOR):
                  any.Unpack(foo)
                  ...

             Example 4: Pack and unpack a message in Go

                 foo := &pb.Foo{...}
                 any, err := ptypes.MarshalAny(foo)
                 ...
                 foo := &pb.Foo{}
                 if err := ptypes.UnmarshalAny(any, foo); err != nil {
                   ...
                 }

            The pack methods provided by protobuf library will by default use

            'type.googleapis.com/full.type.name' as the type URL and the unpack

            methods only use the fully qualified type name after the last '/'

            in the type URL, for example "foo.bar.com/x/y.z" will yield type

            name "y.z".



            JSON

            ====

            The JSON representation of an `Any` value uses the regular

            representation of the deserialized, embedded message, with an

            additional field `@type` which contains the type URL. Example:

                package google.profile;
                message Person {
                  string first_name = 1;
                  string last_name = 2;
                }

                {
                  "@type": "type.googleapis.com/google.profile.Person",
                  "firstName": <string>,
                  "lastName": <string>
                }

            If the embedded message type is well-known and has a custom JSON

            representation, that representation will be embedded adding a field

            `value` which holds the custom JSON in addition to the `@type`

            field. Example (for message [google.protobuf.Duration][]):

                {
                  "@type": "type.googleapis.com/google.protobuf.Duration",
                  "value": "1.212s"
                }
  ibc.applications.transfer.v1.DenomTrace:
    type: object
    properties:
      path:
        type: string
        description: >-
          path defines the chain of port/channel identifiers used for tracing
          the

          source of the fungible token.
      base_denom:
        type: string
        description: base denomination of the relayed fungible token.
    description: >-
      DenomTrace contains the base denomination for ICS20 fungible tokens and
      the

      source tracing information path.
  ibc.applications.transfer.v1.Params:
    type: object
    properties:
      send_enabled:
        type: boolean
        format: boolean
        description: >-
          send_enabled enables or disables all cross-chain token transfers from
          this

          chain.
      receive_enabled:
        type: boolean
        format: boolean
        description: >-
          receive_enabled enables or disables all cross-chain token transfers to
          this

          chain.
    description: >-
      Params defines the set of IBC transfer parameters.

      NOTE: To prevent a single token from being transferred, set the

      TransfersEnabled parameter to true and then set the bank module's
      SendEnabled

      parameter for the denomination to false.
  ibc.applications.transfer.v1.QueryDenomHashResponse:
    type: object
    properties:
      hash:
        type: string
        description: hash (in hex format) of the denomination trace information.
    description: |-
      QueryDenomHashResponse is the response type for the Query/DenomHash RPC
      method.
  ibc.applications.transfer.v1.QueryDenomTraceResponse:
    type: object
    properties:
      denom_trace:
        type: object
        properties:
          path:
            type: string
            description: >-
              path defines the chain of port/channel identifiers used for
              tracing the

              source of the fungible token.
          base_denom:
            type: string
            description: base denomination of the relayed fungible token.
        description: >-
          DenomTrace contains the base denomination for ICS20 fungible tokens
          and the

          source tracing information path.
    description: |-
      QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC
      method.
  ibc.applications.transfer.v1.QueryDenomTracesResponse:
    type: object
    properties:
      denom_traces:
        type: array
        items:
          type: object
          properties:
            path:
              type: string
              description: >-
                path defines the chain of port/channel identifiers used for
                tracing the

                source of the fungible token.
            base_denom:
              type: string
              description: base denomination of the relayed fungible token.
          description: >-
            DenomTrace contains the base denomination for ICS20 fungible tokens
            and the

            source tracing information path.
        description: denom_traces returns all denominations trace information.
      pagination:
        description: pagination defines the pagination in the response.
        type: object
        properties:
          next_key:
            type: string
            format: byte
            title: |-
              next_key is the key to be passed to PageRequest.key to
              query the next page most efficiently
          total:
            type: string
            format: uint64
            title: >-
              total is total number of results available if
              PageRequest.count_total

              was set, its value is undefined otherwise
    description: >-
      QueryConnectionsResponse is the response type for the Query/DenomTraces
      RPC

      method.
  ibc.applications.transfer.v1.QueryEscrowAddressResponse:
    type: object
    properties:
      escrow_address:
        type: string
        title: the escrow account address
    description: >-
      QueryEscrowAddressResponse is the response type of the EscrowAddress RPC
      method.
  ibc.applications.transfer.v1.QueryParamsResponse:
    type: object
    properties:
      params:
        description: params defines the parameters of the module.
        type: object
        properties:
          send_enabled:
            type: boolean
            format: boolean
            description: >-
              send_enabled enables or disables all cross-chain token transfers
              from this

              chain.
          receive_enabled:
            type: boolean
            format: boolean
            description: >-
              receive_enabled enables or disables all cross-chain token
              transfers to this

              chain.
    description: QueryParamsResponse is the response type for the Query/Params RPC method.
  ibc.applications.interchain_accounts.controller.v1.Params:
    type: object
    properties:
      controller_enabled:
        type: boolean
        format: boolean
        description: controller_enabled enables or disables the controller submodule.
    description: |-
      Params defines the set of on-chain interchain accounts parameters.
      The following parameters may be used to disable the controller submodule.
  ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse:
    type: object
    properties:
      address:
        type: string
    description: >-
      QueryInterchainAccountResponse the response type for the
      Query/InterchainAccount RPC method.
  ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse:
    type: object
    properties:
      params:
        description: params defines the parameters of the module.
        type: object
        properties:
          controller_enabled:
            type: boolean
            format: boolean
            description: controller_enabled enables or disables the controller submodule.
    description: QueryParamsResponse is the response type for the Query/Params RPC method.
  ibc.applications.interchain_accounts.host.v1.Params:
    type: object
    properties:
      host_enabled:
        type: boolean
        format: boolean
        description: host_enabled enables or disables the host submodule.
      allow_messages:
        type: array
        items:
          type: string
        description: >-
          allow_messages defines a list of sdk message typeURLs allowed to be
          executed on a host chain.
    description: |-
      Params defines the set of on-chain interchain accounts parameters.
      The following parameters may be used to disable the host submodule.
  ibc.applications.interchain_accounts.host.v1.QueryParamsResponse:
    type: object
    properties:
      params:
        description: params defines the parameters of the module.
        type: object
        properties:
          host_enabled:
            type: boolean
            format: boolean
            description: host_enabled enables or disables the host submodule.
          allow_messages:
            type: array
            items:
              type: string
            description: >-
              allow_messages defines a list of sdk message typeURLs allowed to
              be executed on a host chain.
    description: QueryParamsResponse is the response type for the Query/Params RPC method.
  ibc.core.client.v1.ConsensusStateWithHeight:
    type: object
    properties:
      height:
        title: consensus state height
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
      consensus_state:
        type: object
        properties:
          type_url:
            type: string
            description: >-
              A URL/resource name that uniquely identifies the type of the
              serialized

              protocol buffer message. This string must contain at least

              one "/" character. The last segment of the URL's path must
              represent

              the fully qualified name of the type (as in

              `path/google.protobuf.Duration`). The name should be in a
              canonical form

              (e.g., leading "." is not accepted).


              In practice, teams usually precompile into the binary all types
              that they

              expect it to use in the context of Any. However, for URLs which
              use the

              scheme `http`, `https`, or no scheme, one can optionally set up a
              type

              server that maps type URLs to message definitions as follows:


              * If no scheme is provided, `https` is assumed.

              * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                value in binary format, or produce an error.
              * Applications are allowed to cache lookup results based on the
                URL, or have them precompiled into a binary to avoid any
                lookup. Therefore, binary compatibility needs to be preserved
                on changes to types. (Use versioned type names to manage
                breaking changes.)

              Note: this functionality is not currently available in the
              official

              protobuf release, and it is not used for type URLs beginning with

              type.googleapis.com.


              Schemes other than `http`, `https` (or the empty scheme) might be

              used with implementation specific semantics.
          value:
            type: string
            format: byte
            description: >-
              Must be a valid serialized protocol buffer of the above specified
              type.
        description: >-
          `Any` contains an arbitrary serialized protocol buffer message along
          with a

          URL that describes the type of the serialized message.


          Protobuf library provides support to pack/unpack Any values in the
          form

          of utility functions or additional generated methods of the Any type.


          Example 1: Pack and unpack a message in C++.

              Foo foo = ...;
              Any any;
              any.PackFrom(foo);
              ...
              if (any.UnpackTo(&foo)) {
                ...
              }

          Example 2: Pack and unpack a message in Java.

              Foo foo = ...;
              Any any = Any.pack(foo);
              ...
              if (any.is(Foo.class)) {
                foo = any.unpack(Foo.class);
              }

           Example 3: Pack and unpack a message in Python.

              foo = Foo(...)
              any = Any()
              any.Pack(foo)
              ...
              if any.Is(Foo.DESCRIPTOR):
                any.Unpack(foo)
                ...

           Example 4: Pack and unpack a message in Go

               foo := &pb.Foo{...}
               any, err := ptypes.MarshalAny(foo)
               ...
               foo := &pb.Foo{}
               if err := ptypes.UnmarshalAny(any, foo); err != nil {
                 ...
               }

          The pack methods provided by protobuf library will by default use

          'type.googleapis.com/full.type.name' as the type URL and the unpack

          methods only use the fully qualified type name after the last '/'

          in the type URL, for example "foo.bar.com/x/y.z" will yield type

          name "y.z".



          JSON

          ====

          The JSON representation of an `Any` value uses the regular

          representation of the deserialized, embedded message, with an

          additional field `@type` which contains the type URL. Example:

              package google.profile;
              message Person {
                string first_name = 1;
                string last_name = 2;
              }

              {
                "@type": "type.googleapis.com/google.profile.Person",
                "firstName": <string>,
                "lastName": <string>
              }

          If the embedded message type is well-known and has a custom JSON

          representation, that representation will be embedded adding a field

          `value` which holds the custom JSON in addition to the `@type`

          field. Example (for message [google.protobuf.Duration][]):

              {
                "@type": "type.googleapis.com/google.protobuf.Duration",
                "value": "1.212s"
              }
        title: consensus state
    description: >-
      ConsensusStateWithHeight defines a consensus state with an additional
      height

      field.
  ibc.core.client.v1.Height:
    type: object
    properties:
      revision_number:
        type: string
        format: uint64
        title: the revision that the client is currently on
      revision_height:
        type: string
        format: uint64
        title: the height within the given revision
    description: |-
      Normally the RevisionHeight is incremented at each height while keeping
      RevisionNumber the same. However some consensus algorithms may choose to
      reset the height in certain conditions e.g. hard forks, state-machine
      breaking changes In these cases, the RevisionNumber is incremented so that
      height continues to be monitonically increasing even as the RevisionHeight
      gets reset
    title: >-
      Height is a monotonically increasing data type

      that can be compared against another Height for the purposes of updating
      and

      freezing clients
  ibc.core.client.v1.IdentifiedClientState:
    type: object
    properties:
      client_id:
        type: string
        title: client identifier
      client_state:
        type: object
        properties:
          type_url:
            type: string
            description: >-
              A URL/resource name that uniquely identifies the type of the
              serialized

              protocol buffer message. This string must contain at least

              one "/" character. The last segment of the URL's path must
              represent

              the fully qualified name of the type (as in

              `path/google.protobuf.Duration`). The name should be in a
              canonical form

              (e.g., leading "." is not accepted).


              In practice, teams usually precompile into the binary all types
              that they

              expect it to use in the context of Any. However, for URLs which
              use the

              scheme `http`, `https`, or no scheme, one can optionally set up a
              type

              server that maps type URLs to message definitions as follows:


              * If no scheme is provided, `https` is assumed.

              * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                value in binary format, or produce an error.
              * Applications are allowed to cache lookup results based on the
                URL, or have them precompiled into a binary to avoid any
                lookup. Therefore, binary compatibility needs to be preserved
                on changes to types. (Use versioned type names to manage
                breaking changes.)

              Note: this functionality is not currently available in the
              official

              protobuf release, and it is not used for type URLs beginning with

              type.googleapis.com.


              Schemes other than `http`, `https` (or the empty scheme) might be

              used with implementation specific semantics.
          value:
            type: string
            format: byte
            description: >-
              Must be a valid serialized protocol buffer of the above specified
              type.
        description: >-
          `Any` contains an arbitrary serialized protocol buffer message along
          with a

          URL that describes the type of the serialized message.


          Protobuf library provides support to pack/unpack Any values in the
          form

          of utility functions or additional generated methods of the Any type.


          Example 1: Pack and unpack a message in C++.

              Foo foo = ...;
              Any any;
              any.PackFrom(foo);
              ...
              if (any.UnpackTo(&foo)) {
                ...
              }

          Example 2: Pack and unpack a message in Java.

              Foo foo = ...;
              Any any = Any.pack(foo);
              ...
              if (any.is(Foo.class)) {
                foo = any.unpack(Foo.class);
              }

           Example 3: Pack and unpack a message in Python.

              foo = Foo(...)
              any = Any()
              any.Pack(foo)
              ...
              if any.Is(Foo.DESCRIPTOR):
                any.Unpack(foo)
                ...

           Example 4: Pack and unpack a message in Go

               foo := &pb.Foo{...}
               any, err := ptypes.MarshalAny(foo)
               ...
               foo := &pb.Foo{}
               if err := ptypes.UnmarshalAny(any, foo); err != nil {
                 ...
               }

          The pack methods provided by protobuf library will by default use

          'type.googleapis.com/full.type.name' as the type URL and the unpack

          methods only use the fully qualified type name after the last '/'

          in the type URL, for example "foo.bar.com/x/y.z" will yield type

          name "y.z".



          JSON

          ====

          The JSON representation of an `Any` value uses the regular

          representation of the deserialized, embedded message, with an

          additional field `@type` which contains the type URL. Example:

              package google.profile;
              message Person {
                string first_name = 1;
                string last_name = 2;
              }

              {
                "@type": "type.googleapis.com/google.profile.Person",
                "firstName": <string>,
                "lastName": <string>
              }

          If the embedded message type is well-known and has a custom JSON

          representation, that representation will be embedded adding a field

          `value` which holds the custom JSON in addition to the `@type`

          field. Example (for message [google.protobuf.Duration][]):

              {
                "@type": "type.googleapis.com/google.protobuf.Duration",
                "value": "1.212s"
              }
        title: client state
    description: |-
      IdentifiedClientState defines a client state with an additional client
      identifier field.
  ibc.core.client.v1.Params:
    type: object
    properties:
      allowed_clients:
        type: array
        items:
          type: string
        description: allowed_clients defines the list of allowed client state types.
    description: Params defines the set of IBC light client parameters.
  ibc.core.client.v1.QueryClientParamsResponse:
    type: object
    properties:
      params:
        description: params defines the parameters of the module.
        type: object
        properties:
          allowed_clients:
            type: array
            items:
              type: string
            description: allowed_clients defines the list of allowed client state types.
    description: >-
      QueryClientParamsResponse is the response type for the Query/ClientParams
      RPC

      method.
  ibc.core.client.v1.QueryClientStateResponse:
    type: object
    properties:
      client_state:
        type: object
        properties:
          type_url:
            type: string
            description: >-
              A URL/resource name that uniquely identifies the type of the
              serialized

              protocol buffer message. This string must contain at least

              one "/" character. The last segment of the URL's path must
              represent

              the fully qualified name of the type (as in

              `path/google.protobuf.Duration`). The name should be in a
              canonical form

              (e.g., leading "." is not accepted).


              In practice, teams usually precompile into the binary all types
              that they

              expect it to use in the context of Any. However, for URLs which
              use the

              scheme `http`, `https`, or no scheme, one can optionally set up a
              type

              server that maps type URLs to message definitions as follows:


              * If no scheme is provided, `https` is assumed.

              * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                value in binary format, or produce an error.
              * Applications are allowed to cache lookup results based on the
                URL, or have them precompiled into a binary to avoid any
                lookup. Therefore, binary compatibility needs to be preserved
                on changes to types. (Use versioned type names to manage
                breaking changes.)

              Note: this functionality is not currently available in the
              official

              protobuf release, and it is not used for type URLs beginning with

              type.googleapis.com.


              Schemes other than `http`, `https` (or the empty scheme) might be

              used with implementation specific semantics.
          value:
            type: string
            format: byte
            description: >-
              Must be a valid serialized protocol buffer of the above specified
              type.
        description: >-
          `Any` contains an arbitrary serialized protocol buffer message along
          with a

          URL that describes the type of the serialized message.


          Protobuf library provides support to pack/unpack Any values in the
          form

          of utility functions or additional generated methods of the Any type.


          Example 1: Pack and unpack a message in C++.

              Foo foo = ...;
              Any any;
              any.PackFrom(foo);
              ...
              if (any.UnpackTo(&foo)) {
                ...
              }

          Example 2: Pack and unpack a message in Java.

              Foo foo = ...;
              Any any = Any.pack(foo);
              ...
              if (any.is(Foo.class)) {
                foo = any.unpack(Foo.class);
              }

           Example 3: Pack and unpack a message in Python.

              foo = Foo(...)
              any = Any()
              any.Pack(foo)
              ...
              if any.Is(Foo.DESCRIPTOR):
                any.Unpack(foo)
                ...

           Example 4: Pack and unpack a message in Go

               foo := &pb.Foo{...}
               any, err := ptypes.MarshalAny(foo)
               ...
               foo := &pb.Foo{}
               if err := ptypes.UnmarshalAny(any, foo); err != nil {
                 ...
               }

          The pack methods provided by protobuf library will by default use

          'type.googleapis.com/full.type.name' as the type URL and the unpack

          methods only use the fully qualified type name after the last '/'

          in the type URL, for example "foo.bar.com/x/y.z" will yield type

          name "y.z".



          JSON

          ====

          The JSON representation of an `Any` value uses the regular

          representation of the deserialized, embedded message, with an

          additional field `@type` which contains the type URL. Example:

              package google.profile;
              message Person {
                string first_name = 1;
                string last_name = 2;
              }

              {
                "@type": "type.googleapis.com/google.profile.Person",
                "firstName": <string>,
                "lastName": <string>
              }

          If the embedded message type is well-known and has a custom JSON

          representation, that representation will be embedded adding a field

          `value` which holds the custom JSON in addition to the `@type`

          field. Example (for message [google.protobuf.Duration][]):

              {
                "@type": "type.googleapis.com/google.protobuf.Duration",
                "value": "1.212s"
              }
        title: client state associated with the request identifier
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    description: >-
      QueryClientStateResponse is the response type for the Query/ClientState
      RPC

      method. Besides the client state, it includes a proof and the height from

      which the proof was retrieved.
  ibc.core.client.v1.QueryClientStatesResponse:
    type: object
    properties:
      client_states:
        type: array
        items:
          type: object
          properties:
            client_id:
              type: string
              title: client identifier
            client_state:
              type: object
              properties:
                type_url:
                  type: string
                  description: >-
                    A URL/resource name that uniquely identifies the type of the
                    serialized

                    protocol buffer message. This string must contain at least

                    one "/" character. The last segment of the URL's path must
                    represent

                    the fully qualified name of the type (as in

                    `path/google.protobuf.Duration`). The name should be in a
                    canonical form

                    (e.g., leading "." is not accepted).


                    In practice, teams usually precompile into the binary all
                    types that they

                    expect it to use in the context of Any. However, for URLs
                    which use the

                    scheme `http`, `https`, or no scheme, one can optionally set
                    up a type

                    server that maps type URLs to message definitions as
                    follows:


                    * If no scheme is provided, `https` is assumed.

                    * An HTTP GET on the URL must yield a
                    [google.protobuf.Type][]
                      value in binary format, or produce an error.
                    * Applications are allowed to cache lookup results based on
                    the
                      URL, or have them precompiled into a binary to avoid any
                      lookup. Therefore, binary compatibility needs to be preserved
                      on changes to types. (Use versioned type names to manage
                      breaking changes.)

                    Note: this functionality is not currently available in the
                    official

                    protobuf release, and it is not used for type URLs beginning
                    with

                    type.googleapis.com.


                    Schemes other than `http`, `https` (or the empty scheme)
                    might be

                    used with implementation specific semantics.
                value:
                  type: string
                  format: byte
                  description: >-
                    Must be a valid serialized protocol buffer of the above
                    specified type.
              description: >-
                `Any` contains an arbitrary serialized protocol buffer message
                along with a

                URL that describes the type of the serialized message.


                Protobuf library provides support to pack/unpack Any values in
                the form

                of utility functions or additional generated methods of the Any
                type.


                Example 1: Pack and unpack a message in C++.

                    Foo foo = ...;
                    Any any;
                    any.PackFrom(foo);
                    ...
                    if (any.UnpackTo(&foo)) {
                      ...
                    }

                Example 2: Pack and unpack a message in Java.

                    Foo foo = ...;
                    Any any = Any.pack(foo);
                    ...
                    if (any.is(Foo.class)) {
                      foo = any.unpack(Foo.class);
                    }

                 Example 3: Pack and unpack a message in Python.

                    foo = Foo(...)
                    any = Any()
                    any.Pack(foo)
                    ...
                    if any.Is(Foo.DESCRIPTOR):
                      any.Unpack(foo)
                      ...

                 Example 4: Pack and unpack a message in Go

                     foo := &pb.Foo{...}
                     any, err := ptypes.MarshalAny(foo)
                     ...
                     foo := &pb.Foo{}
                     if err := ptypes.UnmarshalAny(any, foo); err != nil {
                       ...
                     }

                The pack methods provided by protobuf library will by default
                use

                'type.googleapis.com/full.type.name' as the type URL and the
                unpack

                methods only use the fully qualified type name after the last
                '/'

                in the type URL, for example "foo.bar.com/x/y.z" will yield type

                name "y.z".



                JSON

                ====

                The JSON representation of an `Any` value uses the regular

                representation of the deserialized, embedded message, with an

                additional field `@type` which contains the type URL. Example:

                    package google.profile;
                    message Person {
                      string first_name = 1;
                      string last_name = 2;
                    }

                    {
                      "@type": "type.googleapis.com/google.profile.Person",
                      "firstName": <string>,
                      "lastName": <string>
                    }

                If the embedded message type is well-known and has a custom JSON

                representation, that representation will be embedded adding a
                field

                `value` which holds the custom JSON in addition to the `@type`

                field. Example (for message [google.protobuf.Duration][]):

                    {
                      "@type": "type.googleapis.com/google.protobuf.Duration",
                      "value": "1.212s"
                    }
              title: client state
          description: >-
            IdentifiedClientState defines a client state with an additional
            client

            identifier field.
        description: list of stored ClientStates of the chain.
      pagination:
        title: pagination response
        type: object
        properties:
          next_key:
            type: string
            format: byte
            title: |-
              next_key is the key to be passed to PageRequest.key to
              query the next page most efficiently
          total:
            type: string
            format: uint64
            title: >-
              total is total number of results available if
              PageRequest.count_total

              was set, its value is undefined otherwise
        description: |-
          PageResponse is to be embedded in gRPC response messages where the
          corresponding request message has used PageRequest.

           message SomeResponse {
                   repeated Bar results = 1;
                   PageResponse page = 2;
           }
    description: >-
      QueryClientStatesResponse is the response type for the Query/ClientStates
      RPC

      method.
  ibc.core.client.v1.QueryClientStatusResponse:
    type: object
    properties:
      status:
        type: string
    description: >-
      QueryClientStatusResponse is the response type for the Query/ClientStatus
      RPC

      method. It returns the current status of the IBC client.
  ibc.core.client.v1.QueryConsensusStateHeightsResponse:
    type: object
    properties:
      consensus_state_heights:
        type: array
        items:
          type: object
          properties:
            revision_number:
              type: string
              format: uint64
              title: the revision that the client is currently on
            revision_height:
              type: string
              format: uint64
              title: the height within the given revision
          description: >-
            Normally the RevisionHeight is incremented at each height while
            keeping

            RevisionNumber the same. However some consensus algorithms may
            choose to

            reset the height in certain conditions e.g. hard forks,
            state-machine

            breaking changes In these cases, the RevisionNumber is incremented
            so that

            height continues to be monitonically increasing even as the
            RevisionHeight

            gets reset
          title: >-
            Height is a monotonically increasing data type

            that can be compared against another Height for the purposes of
            updating and

            freezing clients
        title: consensus state heights
      pagination:
        title: pagination response
        type: object
        properties:
          next_key:
            type: string
            format: byte
            title: |-
              next_key is the key to be passed to PageRequest.key to
              query the next page most efficiently
          total:
            type: string
            format: uint64
            title: >-
              total is total number of results available if
              PageRequest.count_total

              was set, its value is undefined otherwise
        description: |-
          PageResponse is to be embedded in gRPC response messages where the
          corresponding request message has used PageRequest.

           message SomeResponse {
                   repeated Bar results = 1;
                   PageResponse page = 2;
           }
    title: |-
      QueryConsensusStateHeightsResponse is the response type for the
      Query/ConsensusStateHeights RPC method
  ibc.core.client.v1.QueryConsensusStateResponse:
    type: object
    properties:
      consensus_state:
        type: object
        properties:
          type_url:
            type: string
            description: >-
              A URL/resource name that uniquely identifies the type of the
              serialized

              protocol buffer message. This string must contain at least

              one "/" character. The last segment of the URL's path must
              represent

              the fully qualified name of the type (as in

              `path/google.protobuf.Duration`). The name should be in a
              canonical form

              (e.g., leading "." is not accepted).


              In practice, teams usually precompile into the binary all types
              that they

              expect it to use in the context of Any. However, for URLs which
              use the

              scheme `http`, `https`, or no scheme, one can optionally set up a
              type

              server that maps type URLs to message definitions as follows:


              * If no scheme is provided, `https` is assumed.

              * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                value in binary format, or produce an error.
              * Applications are allowed to cache lookup results based on the
                URL, or have them precompiled into a binary to avoid any
                lookup. Therefore, binary compatibility needs to be preserved
                on changes to types. (Use versioned type names to manage
                breaking changes.)

              Note: this functionality is not currently available in the
              official

              protobuf release, and it is not used for type URLs beginning with

              type.googleapis.com.


              Schemes other than `http`, `https` (or the empty scheme) might be

              used with implementation specific semantics.
          value:
            type: string
            format: byte
            description: >-
              Must be a valid serialized protocol buffer of the above specified
              type.
        description: >-
          `Any` contains an arbitrary serialized protocol buffer message along
          with a

          URL that describes the type of the serialized message.


          Protobuf library provides support to pack/unpack Any values in the
          form

          of utility functions or additional generated methods of the Any type.


          Example 1: Pack and unpack a message in C++.

              Foo foo = ...;
              Any any;
              any.PackFrom(foo);
              ...
              if (any.UnpackTo(&foo)) {
                ...
              }

          Example 2: Pack and unpack a message in Java.

              Foo foo = ...;
              Any any = Any.pack(foo);
              ...
              if (any.is(Foo.class)) {
                foo = any.unpack(Foo.class);
              }

           Example 3: Pack and unpack a message in Python.

              foo = Foo(...)
              any = Any()
              any.Pack(foo)
              ...
              if any.Is(Foo.DESCRIPTOR):
                any.Unpack(foo)
                ...

           Example 4: Pack and unpack a message in Go

               foo := &pb.Foo{...}
               any, err := ptypes.MarshalAny(foo)
               ...
               foo := &pb.Foo{}
               if err := ptypes.UnmarshalAny(any, foo); err != nil {
                 ...
               }

          The pack methods provided by protobuf library will by default use

          'type.googleapis.com/full.type.name' as the type URL and the unpack

          methods only use the fully qualified type name after the last '/'

          in the type URL, for example "foo.bar.com/x/y.z" will yield type

          name "y.z".



          JSON

          ====

          The JSON representation of an `Any` value uses the regular

          representation of the deserialized, embedded message, with an

          additional field `@type` which contains the type URL. Example:

              package google.profile;
              message Person {
                string first_name = 1;
                string last_name = 2;
              }

              {
                "@type": "type.googleapis.com/google.profile.Person",
                "firstName": <string>,
                "lastName": <string>
              }

          If the embedded message type is well-known and has a custom JSON

          representation, that representation will be embedded adding a field

          `value` which holds the custom JSON in addition to the `@type`

          field. Example (for message [google.protobuf.Duration][]):

              {
                "@type": "type.googleapis.com/google.protobuf.Duration",
                "value": "1.212s"
              }
        title: >-
          consensus state associated with the client identifier at the given
          height
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
        title: >-
          Height is a monotonically increasing data type

          that can be compared against another Height for the purposes of
          updating and

          freezing clients
    title: >-
      QueryConsensusStateResponse is the response type for the
      Query/ConsensusState

      RPC method
  ibc.core.client.v1.QueryConsensusStatesResponse:
    type: object
    properties:
      consensus_states:
        type: array
        items:
          type: object
          properties:
            height:
              title: consensus state height
              type: object
              properties:
                revision_number:
                  type: string
                  format: uint64
                  title: the revision that the client is currently on
                revision_height:
                  type: string
                  format: uint64
                  title: the height within the given revision
              description: >-
                Normally the RevisionHeight is incremented at each height while
                keeping

                RevisionNumber the same. However some consensus algorithms may
                choose to

                reset the height in certain conditions e.g. hard forks,
                state-machine

                breaking changes In these cases, the RevisionNumber is
                incremented so that

                height continues to be monitonically increasing even as the
                RevisionHeight

                gets reset
            consensus_state:
              type: object
              properties:
                type_url:
                  type: string
                  description: >-
                    A URL/resource name that uniquely identifies the type of the
                    serialized

                    protocol buffer message. This string must contain at least

                    one "/" character. The last segment of the URL's path must
                    represent

                    the fully qualified name of the type (as in

                    `path/google.protobuf.Duration`). The name should be in a
                    canonical form

                    (e.g., leading "." is not accepted).


                    In practice, teams usually precompile into the binary all
                    types that they

                    expect it to use in the context of Any. However, for URLs
                    which use the

                    scheme `http`, `https`, or no scheme, one can optionally set
                    up a type

                    server that maps type URLs to message definitions as
                    follows:


                    * If no scheme is provided, `https` is assumed.

                    * An HTTP GET on the URL must yield a
                    [google.protobuf.Type][]
                      value in binary format, or produce an error.
                    * Applications are allowed to cache lookup results based on
                    the
                      URL, or have them precompiled into a binary to avoid any
                      lookup. Therefore, binary compatibility needs to be preserved
                      on changes to types. (Use versioned type names to manage
                      breaking changes.)

                    Note: this functionality is not currently available in the
                    official

                    protobuf release, and it is not used for type URLs beginning
                    with

                    type.googleapis.com.


                    Schemes other than `http`, `https` (or the empty scheme)
                    might be

                    used with implementation specific semantics.
                value:
                  type: string
                  format: byte
                  description: >-
                    Must be a valid serialized protocol buffer of the above
                    specified type.
              description: >-
                `Any` contains an arbitrary serialized protocol buffer message
                along with a

                URL that describes the type of the serialized message.


                Protobuf library provides support to pack/unpack Any values in
                the form

                of utility functions or additional generated methods of the Any
                type.


                Example 1: Pack and unpack a message in C++.

                    Foo foo = ...;
                    Any any;
                    any.PackFrom(foo);
                    ...
                    if (any.UnpackTo(&foo)) {
                      ...
                    }

                Example 2: Pack and unpack a message in Java.

                    Foo foo = ...;
                    Any any = Any.pack(foo);
                    ...
                    if (any.is(Foo.class)) {
                      foo = any.unpack(Foo.class);
                    }

                 Example 3: Pack and unpack a message in Python.

                    foo = Foo(...)
                    any = Any()
                    any.Pack(foo)
                    ...
                    if any.Is(Foo.DESCRIPTOR):
                      any.Unpack(foo)
                      ...

                 Example 4: Pack and unpack a message in Go

                     foo := &pb.Foo{...}
                     any, err := ptypes.MarshalAny(foo)
                     ...
                     foo := &pb.Foo{}
                     if err := ptypes.UnmarshalAny(any, foo); err != nil {
                       ...
                     }

                The pack methods provided by protobuf library will by default
                use

                'type.googleapis.com/full.type.name' as the type URL and the
                unpack

                methods only use the fully qualified type name after the last
                '/'

                in the type URL, for example "foo.bar.com/x/y.z" will yield type

                name "y.z".



                JSON

                ====

                The JSON representation of an `Any` value uses the regular

                representation of the deserialized, embedded message, with an

                additional field `@type` which contains the type URL. Example:

                    package google.profile;
                    message Person {
                      string first_name = 1;
                      string last_name = 2;
                    }

                    {
                      "@type": "type.googleapis.com/google.profile.Person",
                      "firstName": <string>,
                      "lastName": <string>
                    }

                If the embedded message type is well-known and has a custom JSON

                representation, that representation will be embedded adding a
                field

                `value` which holds the custom JSON in addition to the `@type`

                field. Example (for message [google.protobuf.Duration][]):

                    {
                      "@type": "type.googleapis.com/google.protobuf.Duration",
                      "value": "1.212s"
                    }
              title: consensus state
          description: >-
            ConsensusStateWithHeight defines a consensus state with an
            additional height

            field.
        title: consensus states associated with the identifier
      pagination:
        title: pagination response
        type: object
        properties:
          next_key:
            type: string
            format: byte
            title: |-
              next_key is the key to be passed to PageRequest.key to
              query the next page most efficiently
          total:
            type: string
            format: uint64
            title: >-
              total is total number of results available if
              PageRequest.count_total

              was set, its value is undefined otherwise
        description: |-
          PageResponse is to be embedded in gRPC response messages where the
          corresponding request message has used PageRequest.

           message SomeResponse {
                   repeated Bar results = 1;
                   PageResponse page = 2;
           }
    title: |-
      QueryConsensusStatesResponse is the response type for the
      Query/ConsensusStates RPC method
  ibc.core.client.v1.QueryUpgradedClientStateResponse:
    type: object
    properties:
      upgraded_client_state:
        type: object
        properties:
          type_url:
            type: string
            description: >-
              A URL/resource name that uniquely identifies the type of the
              serialized

              protocol buffer message. This string must contain at least

              one "/" character. The last segment of the URL's path must
              represent

              the fully qualified name of the type (as in

              `path/google.protobuf.Duration`). The name should be in a
              canonical form

              (e.g., leading "." is not accepted).


              In practice, teams usually precompile into the binary all types
              that they

              expect it to use in the context of Any. However, for URLs which
              use the

              scheme `http`, `https`, or no scheme, one can optionally set up a
              type

              server that maps type URLs to message definitions as follows:


              * If no scheme is provided, `https` is assumed.

              * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                value in binary format, or produce an error.
              * Applications are allowed to cache lookup results based on the
                URL, or have them precompiled into a binary to avoid any
                lookup. Therefore, binary compatibility needs to be preserved
                on changes to types. (Use versioned type names to manage
                breaking changes.)

              Note: this functionality is not currently available in the
              official

              protobuf release, and it is not used for type URLs beginning with

              type.googleapis.com.


              Schemes other than `http`, `https` (or the empty scheme) might be

              used with implementation specific semantics.
          value:
            type: string
            format: byte
            description: >-
              Must be a valid serialized protocol buffer of the above specified
              type.
        description: >-
          `Any` contains an arbitrary serialized protocol buffer message along
          with a

          URL that describes the type of the serialized message.


          Protobuf library provides support to pack/unpack Any values in the
          form

          of utility functions or additional generated methods of the Any type.


          Example 1: Pack and unpack a message in C++.

              Foo foo = ...;
              Any any;
              any.PackFrom(foo);
              ...
              if (any.UnpackTo(&foo)) {
                ...
              }

          Example 2: Pack and unpack a message in Java.

              Foo foo = ...;
              Any any = Any.pack(foo);
              ...
              if (any.is(Foo.class)) {
                foo = any.unpack(Foo.class);
              }

           Example 3: Pack and unpack a message in Python.

              foo = Foo(...)
              any = Any()
              any.Pack(foo)
              ...
              if any.Is(Foo.DESCRIPTOR):
                any.Unpack(foo)
                ...

           Example 4: Pack and unpack a message in Go

               foo := &pb.Foo{...}
               any, err := ptypes.MarshalAny(foo)
               ...
               foo := &pb.Foo{}
               if err := ptypes.UnmarshalAny(any, foo); err != nil {
                 ...
               }

          The pack methods provided by protobuf library will by default use

          'type.googleapis.com/full.type.name' as the type URL and the unpack

          methods only use the fully qualified type name after the last '/'

          in the type URL, for example "foo.bar.com/x/y.z" will yield type

          name "y.z".



          JSON

          ====

          The JSON representation of an `Any` value uses the regular

          representation of the deserialized, embedded message, with an

          additional field `@type` which contains the type URL. Example:

              package google.profile;
              message Person {
                string first_name = 1;
                string last_name = 2;
              }

              {
                "@type": "type.googleapis.com/google.profile.Person",
                "firstName": <string>,
                "lastName": <string>
              }

          If the embedded message type is well-known and has a custom JSON

          representation, that representation will be embedded adding a field

          `value` which holds the custom JSON in addition to the `@type`

          field. Example (for message [google.protobuf.Duration][]):

              {
                "@type": "type.googleapis.com/google.protobuf.Duration",
                "value": "1.212s"
              }
        title: client state associated with the request identifier
    description: |-
      QueryUpgradedClientStateResponse is the response type for the
      Query/UpgradedClientState RPC method.
  ibc.core.client.v1.QueryUpgradedConsensusStateResponse:
    type: object
    properties:
      upgraded_consensus_state:
        type: object
        properties:
          type_url:
            type: string
            description: >-
              A URL/resource name that uniquely identifies the type of the
              serialized

              protocol buffer message. This string must contain at least

              one "/" character. The last segment of the URL's path must
              represent

              the fully qualified name of the type (as in

              `path/google.protobuf.Duration`). The name should be in a
              canonical form

              (e.g., leading "." is not accepted).


              In practice, teams usually precompile into the binary all types
              that they

              expect it to use in the context of Any. However, for URLs which
              use the

              scheme `http`, `https`, or no scheme, one can optionally set up a
              type

              server that maps type URLs to message definitions as follows:


              * If no scheme is provided, `https` is assumed.

              * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                value in binary format, or produce an error.
              * Applications are allowed to cache lookup results based on the
                URL, or have them precompiled into a binary to avoid any
                lookup. Therefore, binary compatibility needs to be preserved
                on changes to types. (Use versioned type names to manage
                breaking changes.)

              Note: this functionality is not currently available in the
              official

              protobuf release, and it is not used for type URLs beginning with

              type.googleapis.com.


              Schemes other than `http`, `https` (or the empty scheme) might be

              used with implementation specific semantics.
          value:
            type: string
            format: byte
            description: >-
              Must be a valid serialized protocol buffer of the above specified
              type.
        description: >-
          `Any` contains an arbitrary serialized protocol buffer message along
          with a

          URL that describes the type of the serialized message.


          Protobuf library provides support to pack/unpack Any values in the
          form

          of utility functions or additional generated methods of the Any type.


          Example 1: Pack and unpack a message in C++.

              Foo foo = ...;
              Any any;
              any.PackFrom(foo);
              ...
              if (any.UnpackTo(&foo)) {
                ...
              }

          Example 2: Pack and unpack a message in Java.

              Foo foo = ...;
              Any any = Any.pack(foo);
              ...
              if (any.is(Foo.class)) {
                foo = any.unpack(Foo.class);
              }

           Example 3: Pack and unpack a message in Python.

              foo = Foo(...)
              any = Any()
              any.Pack(foo)
              ...
              if any.Is(Foo.DESCRIPTOR):
                any.Unpack(foo)
                ...

           Example 4: Pack and unpack a message in Go

               foo := &pb.Foo{...}
               any, err := ptypes.MarshalAny(foo)
               ...
               foo := &pb.Foo{}
               if err := ptypes.UnmarshalAny(any, foo); err != nil {
                 ...
               }

          The pack methods provided by protobuf library will by default use

          'type.googleapis.com/full.type.name' as the type URL and the unpack

          methods only use the fully qualified type name after the last '/'

          in the type URL, for example "foo.bar.com/x/y.z" will yield type

          name "y.z".



          JSON

          ====

          The JSON representation of an `Any` value uses the regular

          representation of the deserialized, embedded message, with an

          additional field `@type` which contains the type URL. Example:

              package google.profile;
              message Person {
                string first_name = 1;
                string last_name = 2;
              }

              {
                "@type": "type.googleapis.com/google.profile.Person",
                "firstName": <string>,
                "lastName": <string>
              }

          If the embedded message type is well-known and has a custom JSON

          representation, that representation will be embedded adding a field

          `value` which holds the custom JSON in addition to the `@type`

          field. Example (for message [google.protobuf.Duration][]):

              {
                "@type": "type.googleapis.com/google.protobuf.Duration",
                "value": "1.212s"
              }
        title: Consensus state associated with the request identifier
    description: |-
      QueryUpgradedConsensusStateResponse is the response type for the
      Query/UpgradedConsensusState RPC method.
  ibc.core.commitment.v1.MerklePrefix:
    type: object
    properties:
      key_prefix:
        type: string
        format: byte
    title: |-
      MerklePrefix is merkle path prefixed to the key.
      The constructed key from the Path and the key will be append(Path.KeyPath,
      append(Path.KeyPrefix, key...))
  ibc.core.connection.v1.ConnectionEnd:
    type: object
    properties:
      client_id:
        type: string
        description: client associated with this connection.
      versions:
        type: array
        items:
          type: object
          properties:
            identifier:
              type: string
              title: unique version identifier
            features:
              type: array
              items:
                type: string
              title: list of features compatible with the specified identifier
          description: >-
            Version defines the versioning scheme used to negotiate the IBC
            verison in

            the connection handshake.
        description: >-
          IBC version which can be utilised to determine encodings or protocols
          for

          channels or packets utilising this connection.
      state:
        description: current state of the connection end.
        type: string
        enum:
          - STATE_UNINITIALIZED_UNSPECIFIED
          - STATE_INIT
          - STATE_TRYOPEN
          - STATE_OPEN
        default: STATE_UNINITIALIZED_UNSPECIFIED
      counterparty:
        description: counterparty chain associated with this connection.
        type: object
        properties:
          client_id:
            type: string
            description: >-
              identifies the client on the counterparty chain associated with a
              given

              connection.
          connection_id:
            type: string
            description: >-
              identifies the connection end on the counterparty chain associated
              with a

              given connection.
          prefix:
            description: commitment merkle prefix of the counterparty chain.
            type: object
            properties:
              key_prefix:
                type: string
                format: byte
            title: >-
              MerklePrefix is merkle path prefixed to the key.

              The constructed key from the Path and the key will be
              append(Path.KeyPath,

              append(Path.KeyPrefix, key...))
      delay_period:
        type: string
        format: uint64
        description: >-
          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.
    description: |-
      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.
  ibc.core.connection.v1.Counterparty:
    type: object
    properties:
      client_id:
        type: string
        description: >-
          identifies the client on the counterparty chain associated with a
          given

          connection.
      connection_id:
        type: string
        description: >-
          identifies the connection end on the counterparty chain associated
          with a

          given connection.
      prefix:
        description: commitment merkle prefix of the counterparty chain.
        type: object
        properties:
          key_prefix:
            type: string
            format: byte
        title: >-
          MerklePrefix is merkle path prefixed to the key.

          The constructed key from the Path and the key will be
          append(Path.KeyPath,

          append(Path.KeyPrefix, key...))
    description: >-
      Counterparty defines the counterparty chain associated with a connection
      end.
  ibc.core.connection.v1.IdentifiedConnection:
    type: object
    properties:
      id:
        type: string
        description: connection identifier.
      client_id:
        type: string
        description: client associated with this connection.
      versions:
        type: array
        items:
          type: object
          properties:
            identifier:
              type: string
              title: unique version identifier
            features:
              type: array
              items:
                type: string
              title: list of features compatible with the specified identifier
          description: >-
            Version defines the versioning scheme used to negotiate the IBC
            verison in

            the connection handshake.
        title: >-
          IBC version which can be utilised to determine encodings or protocols
          for

          channels or packets utilising this connection
      state:
        description: current state of the connection end.
        type: string
        enum:
          - STATE_UNINITIALIZED_UNSPECIFIED
          - STATE_INIT
          - STATE_TRYOPEN
          - STATE_OPEN
        default: STATE_UNINITIALIZED_UNSPECIFIED
      counterparty:
        description: counterparty chain associated with this connection.
        type: object
        properties:
          client_id:
            type: string
            description: >-
              identifies the client on the counterparty chain associated with a
              given

              connection.
          connection_id:
            type: string
            description: >-
              identifies the connection end on the counterparty chain associated
              with a

              given connection.
          prefix:
            description: commitment merkle prefix of the counterparty chain.
            type: object
            properties:
              key_prefix:
                type: string
                format: byte
            title: >-
              MerklePrefix is merkle path prefixed to the key.

              The constructed key from the Path and the key will be
              append(Path.KeyPath,

              append(Path.KeyPrefix, key...))
      delay_period:
        type: string
        format: uint64
        description: delay period associated with this connection.
    description: |-
      IdentifiedConnection defines a connection with additional connection
      identifier field.
  ibc.core.connection.v1.QueryClientConnectionsResponse:
    type: object
    properties:
      connection_paths:
        type: array
        items:
          type: string
        description: slice of all the connection paths associated with a client.
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was generated
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryClientConnectionsResponse is the response type for the
      Query/ClientConnections RPC method
  ibc.core.connection.v1.QueryConnectionClientStateResponse:
    type: object
    properties:
      identified_client_state:
        title: client state associated with the channel
        type: object
        properties:
          client_id:
            type: string
            title: client identifier
          client_state:
            type: object
            properties:
              type_url:
                type: string
                description: >-
                  A URL/resource name that uniquely identifies the type of the
                  serialized

                  protocol buffer message. This string must contain at least

                  one "/" character. The last segment of the URL's path must
                  represent

                  the fully qualified name of the type (as in

                  `path/google.protobuf.Duration`). The name should be in a
                  canonical form

                  (e.g., leading "." is not accepted).


                  In practice, teams usually precompile into the binary all
                  types that they

                  expect it to use in the context of Any. However, for URLs
                  which use the

                  scheme `http`, `https`, or no scheme, one can optionally set
                  up a type

                  server that maps type URLs to message definitions as follows:


                  * If no scheme is provided, `https` is assumed.

                  * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                    value in binary format, or produce an error.
                  * Applications are allowed to cache lookup results based on
                  the
                    URL, or have them precompiled into a binary to avoid any
                    lookup. Therefore, binary compatibility needs to be preserved
                    on changes to types. (Use versioned type names to manage
                    breaking changes.)

                  Note: this functionality is not currently available in the
                  official

                  protobuf release, and it is not used for type URLs beginning
                  with

                  type.googleapis.com.


                  Schemes other than `http`, `https` (or the empty scheme) might
                  be

                  used with implementation specific semantics.
              value:
                type: string
                format: byte
                description: >-
                  Must be a valid serialized protocol buffer of the above
                  specified type.
            description: >-
              `Any` contains an arbitrary serialized protocol buffer message
              along with a

              URL that describes the type of the serialized message.


              Protobuf library provides support to pack/unpack Any values in the
              form

              of utility functions or additional generated methods of the Any
              type.


              Example 1: Pack and unpack a message in C++.

                  Foo foo = ...;
                  Any any;
                  any.PackFrom(foo);
                  ...
                  if (any.UnpackTo(&foo)) {
                    ...
                  }

              Example 2: Pack and unpack a message in Java.

                  Foo foo = ...;
                  Any any = Any.pack(foo);
                  ...
                  if (any.is(Foo.class)) {
                    foo = any.unpack(Foo.class);
                  }

               Example 3: Pack and unpack a message in Python.

                  foo = Foo(...)
                  any = Any()
                  any.Pack(foo)
                  ...
                  if any.Is(Foo.DESCRIPTOR):
                    any.Unpack(foo)
                    ...

               Example 4: Pack and unpack a message in Go

                   foo := &pb.Foo{...}
                   any, err := ptypes.MarshalAny(foo)
                   ...
                   foo := &pb.Foo{}
                   if err := ptypes.UnmarshalAny(any, foo); err != nil {
                     ...
                   }

              The pack methods provided by protobuf library will by default use

              'type.googleapis.com/full.type.name' as the type URL and the
              unpack

              methods only use the fully qualified type name after the last '/'

              in the type URL, for example "foo.bar.com/x/y.z" will yield type

              name "y.z".



              JSON

              ====

              The JSON representation of an `Any` value uses the regular

              representation of the deserialized, embedded message, with an

              additional field `@type` which contains the type URL. Example:

                  package google.profile;
                  message Person {
                    string first_name = 1;
                    string last_name = 2;
                  }

                  {
                    "@type": "type.googleapis.com/google.profile.Person",
                    "firstName": <string>,
                    "lastName": <string>
                  }

              If the embedded message type is well-known and has a custom JSON

              representation, that representation will be embedded adding a
              field

              `value` which holds the custom JSON in addition to the `@type`

              field. Example (for message [google.protobuf.Duration][]):

                  {
                    "@type": "type.googleapis.com/google.protobuf.Duration",
                    "value": "1.212s"
                  }
            title: client state
        description: |-
          IdentifiedClientState defines a client state with an additional client
          identifier field.
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryConnectionClientStateResponse is the response type for the
      Query/ConnectionClientState RPC method
  ibc.core.connection.v1.QueryConnectionConsensusStateResponse:
    type: object
    properties:
      consensus_state:
        type: object
        properties:
          type_url:
            type: string
            description: >-
              A URL/resource name that uniquely identifies the type of the
              serialized

              protocol buffer message. This string must contain at least

              one "/" character. The last segment of the URL's path must
              represent

              the fully qualified name of the type (as in

              `path/google.protobuf.Duration`). The name should be in a
              canonical form

              (e.g., leading "." is not accepted).


              In practice, teams usually precompile into the binary all types
              that they

              expect it to use in the context of Any. However, for URLs which
              use the

              scheme `http`, `https`, or no scheme, one can optionally set up a
              type

              server that maps type URLs to message definitions as follows:


              * If no scheme is provided, `https` is assumed.

              * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                value in binary format, or produce an error.
              * Applications are allowed to cache lookup results based on the
                URL, or have them precompiled into a binary to avoid any
                lookup. Therefore, binary compatibility needs to be preserved
                on changes to types. (Use versioned type names to manage
                breaking changes.)

              Note: this functionality is not currently available in the
              official

              protobuf release, and it is not used for type URLs beginning with

              type.googleapis.com.


              Schemes other than `http`, `https` (or the empty scheme) might be

              used with implementation specific semantics.
          value:
            type: string
            format: byte
            description: >-
              Must be a valid serialized protocol buffer of the above specified
              type.
        description: >-
          `Any` contains an arbitrary serialized protocol buffer message along
          with a

          URL that describes the type of the serialized message.


          Protobuf library provides support to pack/unpack Any values in the
          form

          of utility functions or additional generated methods of the Any type.


          Example 1: Pack and unpack a message in C++.

              Foo foo = ...;
              Any any;
              any.PackFrom(foo);
              ...
              if (any.UnpackTo(&foo)) {
                ...
              }

          Example 2: Pack and unpack a message in Java.

              Foo foo = ...;
              Any any = Any.pack(foo);
              ...
              if (any.is(Foo.class)) {
                foo = any.unpack(Foo.class);
              }

           Example 3: Pack and unpack a message in Python.

              foo = Foo(...)
              any = Any()
              any.Pack(foo)
              ...
              if any.Is(Foo.DESCRIPTOR):
                any.Unpack(foo)
                ...

           Example 4: Pack and unpack a message in Go

               foo := &pb.Foo{...}
               any, err := ptypes.MarshalAny(foo)
               ...
               foo := &pb.Foo{}
               if err := ptypes.UnmarshalAny(any, foo); err != nil {
                 ...
               }

          The pack methods provided by protobuf library will by default use

          'type.googleapis.com/full.type.name' as the type URL and the unpack

          methods only use the fully qualified type name after the last '/'

          in the type URL, for example "foo.bar.com/x/y.z" will yield type

          name "y.z".



          JSON

          ====

          The JSON representation of an `Any` value uses the regular

          representation of the deserialized, embedded message, with an

          additional field `@type` which contains the type URL. Example:

              package google.profile;
              message Person {
                string first_name = 1;
                string last_name = 2;
              }

              {
                "@type": "type.googleapis.com/google.profile.Person",
                "firstName": <string>,
                "lastName": <string>
              }

          If the embedded message type is well-known and has a custom JSON

          representation, that representation will be embedded adding a field

          `value` which holds the custom JSON in addition to the `@type`

          field. Example (for message [google.protobuf.Duration][]):

              {
                "@type": "type.googleapis.com/google.protobuf.Duration",
                "value": "1.212s"
              }
        title: consensus state associated with the channel
      client_id:
        type: string
        title: client ID associated with the consensus state
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryConnectionConsensusStateResponse is the response type for the
      Query/ConnectionConsensusState RPC method
  ibc.core.connection.v1.QueryConnectionResponse:
    type: object
    properties:
      connection:
        title: connection associated with the request identifier
        type: object
        properties:
          client_id:
            type: string
            description: client associated with this connection.
          versions:
            type: array
            items:
              type: object
              properties:
                identifier:
                  type: string
                  title: unique version identifier
                features:
                  type: array
                  items:
                    type: string
                  title: list of features compatible with the specified identifier
              description: >-
                Version defines the versioning scheme used to negotiate the IBC
                verison in

                the connection handshake.
            description: >-
              IBC version which can be utilised to determine encodings or
              protocols for

              channels or packets utilising this connection.
          state:
            description: current state of the connection end.
            type: string
            enum:
              - STATE_UNINITIALIZED_UNSPECIFIED
              - STATE_INIT
              - STATE_TRYOPEN
              - STATE_OPEN
            default: STATE_UNINITIALIZED_UNSPECIFIED
          counterparty:
            description: counterparty chain associated with this connection.
            type: object
            properties:
              client_id:
                type: string
                description: >-
                  identifies the client on the counterparty chain associated
                  with a given

                  connection.
              connection_id:
                type: string
                description: >-
                  identifies the connection end on the counterparty chain
                  associated with a

                  given connection.
              prefix:
                description: commitment merkle prefix of the counterparty chain.
                type: object
                properties:
                  key_prefix:
                    type: string
                    format: byte
                title: >-
                  MerklePrefix is merkle path prefixed to the key.

                  The constructed key from the Path and the key will be
                  append(Path.KeyPath,

                  append(Path.KeyPrefix, key...))
          delay_period:
            type: string
            format: uint64
            description: >-
              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.
        description: >-
          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.
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    description: >-
      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.
  ibc.core.connection.v1.QueryConnectionsResponse:
    type: object
    properties:
      connections:
        type: array
        items:
          type: object
          properties:
            id:
              type: string
              description: connection identifier.
            client_id:
              type: string
              description: client associated with this connection.
            versions:
              type: array
              items:
                type: object
                properties:
                  identifier:
                    type: string
                    title: unique version identifier
                  features:
                    type: array
                    items:
                      type: string
                    title: list of features compatible with the specified identifier
                description: >-
                  Version defines the versioning scheme used to negotiate the
                  IBC verison in

                  the connection handshake.
              title: >-
                IBC version which can be utilised to determine encodings or
                protocols for

                channels or packets utilising this connection
            state:
              description: current state of the connection end.
              type: string
              enum:
                - STATE_UNINITIALIZED_UNSPECIFIED
                - STATE_INIT
                - STATE_TRYOPEN
                - STATE_OPEN
              default: STATE_UNINITIALIZED_UNSPECIFIED
            counterparty:
              description: counterparty chain associated with this connection.
              type: object
              properties:
                client_id:
                  type: string
                  description: >-
                    identifies the client on the counterparty chain associated
                    with a given

                    connection.
                connection_id:
                  type: string
                  description: >-
                    identifies the connection end on the counterparty chain
                    associated with a

                    given connection.
                prefix:
                  description: commitment merkle prefix of the counterparty chain.
                  type: object
                  properties:
                    key_prefix:
                      type: string
                      format: byte
                  title: >-
                    MerklePrefix is merkle path prefixed to the key.

                    The constructed key from the Path and the key will be
                    append(Path.KeyPath,

                    append(Path.KeyPrefix, key...))
            delay_period:
              type: string
              format: uint64
              description: delay period associated with this connection.
          description: |-
            IdentifiedConnection defines a connection with additional connection
            identifier field.
        description: list of stored connections of the chain.
      pagination:
        title: pagination response
        type: object
        properties:
          next_key:
            type: string
            format: byte
            title: |-
              next_key is the key to be passed to PageRequest.key to
              query the next page most efficiently
          total:
            type: string
            format: uint64
            title: >-
              total is total number of results available if
              PageRequest.count_total

              was set, its value is undefined otherwise
        description: |-
          PageResponse is to be embedded in gRPC response messages where the
          corresponding request message has used PageRequest.

           message SomeResponse {
                   repeated Bar results = 1;
                   PageResponse page = 2;
           }
      height:
        title: query block height
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    description: >-
      QueryConnectionsResponse is the response type for the Query/Connections
      RPC

      method.
  ibc.core.connection.v1.State:
    type: string
    enum:
      - STATE_UNINITIALIZED_UNSPECIFIED
      - STATE_INIT
      - STATE_TRYOPEN
      - STATE_OPEN
    default: STATE_UNINITIALIZED_UNSPECIFIED
    description: |-
      State defines if a connection is in one of the following states:
      INIT, TRYOPEN, OPEN or UNINITIALIZED.

       - STATE_UNINITIALIZED_UNSPECIFIED: Default State
       - STATE_INIT: A connection end has just started the opening handshake.
       - STATE_TRYOPEN: A connection end has acknowledged the handshake step on the counterparty
      chain.
       - STATE_OPEN: A connection end has completed the handshake.
  ibc.core.connection.v1.Version:
    type: object
    properties:
      identifier:
        type: string
        title: unique version identifier
      features:
        type: array
        items:
          type: string
        title: list of features compatible with the specified identifier
    description: |-
      Version defines the versioning scheme used to negotiate the IBC verison in
      the connection handshake.
  ibc.core.channel.v1.Channel:
    type: object
    properties:
      state:
        title: current state of the channel end
        type: string
        enum:
          - STATE_UNINITIALIZED_UNSPECIFIED
          - STATE_INIT
          - STATE_TRYOPEN
          - STATE_OPEN
          - STATE_CLOSED
        default: STATE_UNINITIALIZED_UNSPECIFIED
        description: |-
          State defines if a channel is in one of the following states:
          CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.

           - STATE_UNINITIALIZED_UNSPECIFIED: Default State
           - STATE_INIT: A channel has just started the opening handshake.
           - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.
           - STATE_OPEN: A channel has completed the handshake. Open channels are
          ready to send and receive packets.
           - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive
          packets.
      ordering:
        title: whether the channel is ordered or unordered
        type: string
        enum:
          - ORDER_NONE_UNSPECIFIED
          - ORDER_UNORDERED
          - ORDER_ORDERED
        default: ORDER_NONE_UNSPECIFIED
        description: |-
          - ORDER_NONE_UNSPECIFIED: zero-value for channel ordering
           - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in
          which they were sent.
           - ORDER_ORDERED: packets are delivered exactly in the order which they were sent
      counterparty:
        title: counterparty channel end
        type: object
        properties:
          port_id:
            type: string
            description: >-
              port on the counterparty chain which owns the other end of the
              channel.
          channel_id:
            type: string
            title: channel end on the counterparty chain
      connection_hops:
        type: array
        items:
          type: string
        title: |-
          list of connection identifiers, in order, along which packets sent on
          this channel will travel
      version:
        type: string
        title: 'opaque channel version, which is agreed upon during the handshake'
    description: |-
      Channel defines pipeline for exactly-once packet delivery between specific
      modules on separate blockchains, which has at least one end capable of
      sending packets and one end capable of receiving packets.
  ibc.core.channel.v1.Counterparty:
    type: object
    properties:
      port_id:
        type: string
        description: >-
          port on the counterparty chain which owns the other end of the
          channel.
      channel_id:
        type: string
        title: channel end on the counterparty chain
    title: Counterparty defines a channel end counterparty
  ibc.core.channel.v1.IdentifiedChannel:
    type: object
    properties:
      state:
        title: current state of the channel end
        type: string
        enum:
          - STATE_UNINITIALIZED_UNSPECIFIED
          - STATE_INIT
          - STATE_TRYOPEN
          - STATE_OPEN
          - STATE_CLOSED
        default: STATE_UNINITIALIZED_UNSPECIFIED
        description: |-
          State defines if a channel is in one of the following states:
          CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.

           - STATE_UNINITIALIZED_UNSPECIFIED: Default State
           - STATE_INIT: A channel has just started the opening handshake.
           - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.
           - STATE_OPEN: A channel has completed the handshake. Open channels are
          ready to send and receive packets.
           - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive
          packets.
      ordering:
        title: whether the channel is ordered or unordered
        type: string
        enum:
          - ORDER_NONE_UNSPECIFIED
          - ORDER_UNORDERED
          - ORDER_ORDERED
        default: ORDER_NONE_UNSPECIFIED
        description: |-
          - ORDER_NONE_UNSPECIFIED: zero-value for channel ordering
           - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in
          which they were sent.
           - ORDER_ORDERED: packets are delivered exactly in the order which they were sent
      counterparty:
        title: counterparty channel end
        type: object
        properties:
          port_id:
            type: string
            description: >-
              port on the counterparty chain which owns the other end of the
              channel.
          channel_id:
            type: string
            title: channel end on the counterparty chain
      connection_hops:
        type: array
        items:
          type: string
        title: |-
          list of connection identifiers, in order, along which packets sent on
          this channel will travel
      version:
        type: string
        title: 'opaque channel version, which is agreed upon during the handshake'
      port_id:
        type: string
        title: port identifier
      channel_id:
        type: string
        title: channel identifier
    description: |-
      IdentifiedChannel defines a channel with additional port and channel
      identifier fields.
  ibc.core.channel.v1.Order:
    type: string
    enum:
      - ORDER_NONE_UNSPECIFIED
      - ORDER_UNORDERED
      - ORDER_ORDERED
    default: ORDER_NONE_UNSPECIFIED
    description: |-
      - ORDER_NONE_UNSPECIFIED: zero-value for channel ordering
       - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in
      which they were sent.
       - ORDER_ORDERED: packets are delivered exactly in the order which they were sent
    title: Order defines if a channel is ORDERED or UNORDERED
  ibc.core.channel.v1.PacketState:
    type: object
    properties:
      port_id:
        type: string
        description: channel port identifier.
      channel_id:
        type: string
        description: channel unique identifier.
      sequence:
        type: string
        format: uint64
        description: packet sequence.
      data:
        type: string
        format: byte
        description: embedded data that represents packet state.
    description: |-
      PacketState defines the generic type necessary to retrieve and store
      packet commitments, acknowledgements, and receipts.
      Caller is responsible for knowing the context necessary to interpret this
      state as a commitment, acknowledgement, or a receipt.
  ibc.core.channel.v1.QueryChannelClientStateResponse:
    type: object
    properties:
      identified_client_state:
        title: client state associated with the channel
        type: object
        properties:
          client_id:
            type: string
            title: client identifier
          client_state:
            type: object
            properties:
              type_url:
                type: string
                description: >-
                  A URL/resource name that uniquely identifies the type of the
                  serialized

                  protocol buffer message. This string must contain at least

                  one "/" character. The last segment of the URL's path must
                  represent

                  the fully qualified name of the type (as in

                  `path/google.protobuf.Duration`). The name should be in a
                  canonical form

                  (e.g., leading "." is not accepted).


                  In practice, teams usually precompile into the binary all
                  types that they

                  expect it to use in the context of Any. However, for URLs
                  which use the

                  scheme `http`, `https`, or no scheme, one can optionally set
                  up a type

                  server that maps type URLs to message definitions as follows:


                  * If no scheme is provided, `https` is assumed.

                  * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                    value in binary format, or produce an error.
                  * Applications are allowed to cache lookup results based on
                  the
                    URL, or have them precompiled into a binary to avoid any
                    lookup. Therefore, binary compatibility needs to be preserved
                    on changes to types. (Use versioned type names to manage
                    breaking changes.)

                  Note: this functionality is not currently available in the
                  official

                  protobuf release, and it is not used for type URLs beginning
                  with

                  type.googleapis.com.


                  Schemes other than `http`, `https` (or the empty scheme) might
                  be

                  used with implementation specific semantics.
              value:
                type: string
                format: byte
                description: >-
                  Must be a valid serialized protocol buffer of the above
                  specified type.
            description: >-
              `Any` contains an arbitrary serialized protocol buffer message
              along with a

              URL that describes the type of the serialized message.


              Protobuf library provides support to pack/unpack Any values in the
              form

              of utility functions or additional generated methods of the Any
              type.


              Example 1: Pack and unpack a message in C++.

                  Foo foo = ...;
                  Any any;
                  any.PackFrom(foo);
                  ...
                  if (any.UnpackTo(&foo)) {
                    ...
                  }

              Example 2: Pack and unpack a message in Java.

                  Foo foo = ...;
                  Any any = Any.pack(foo);
                  ...
                  if (any.is(Foo.class)) {
                    foo = any.unpack(Foo.class);
                  }

               Example 3: Pack and unpack a message in Python.

                  foo = Foo(...)
                  any = Any()
                  any.Pack(foo)
                  ...
                  if any.Is(Foo.DESCRIPTOR):
                    any.Unpack(foo)
                    ...

               Example 4: Pack and unpack a message in Go

                   foo := &pb.Foo{...}
                   any, err := ptypes.MarshalAny(foo)
                   ...
                   foo := &pb.Foo{}
                   if err := ptypes.UnmarshalAny(any, foo); err != nil {
                     ...
                   }

              The pack methods provided by protobuf library will by default use

              'type.googleapis.com/full.type.name' as the type URL and the
              unpack

              methods only use the fully qualified type name after the last '/'

              in the type URL, for example "foo.bar.com/x/y.z" will yield type

              name "y.z".



              JSON

              ====

              The JSON representation of an `Any` value uses the regular

              representation of the deserialized, embedded message, with an

              additional field `@type` which contains the type URL. Example:

                  package google.profile;
                  message Person {
                    string first_name = 1;
                    string last_name = 2;
                  }

                  {
                    "@type": "type.googleapis.com/google.profile.Person",
                    "firstName": <string>,
                    "lastName": <string>
                  }

              If the embedded message type is well-known and has a custom JSON

              representation, that representation will be embedded adding a
              field

              `value` which holds the custom JSON in addition to the `@type`

              field. Example (for message [google.protobuf.Duration][]):

                  {
                    "@type": "type.googleapis.com/google.protobuf.Duration",
                    "value": "1.212s"
                  }
            title: client state
        description: |-
          IdentifiedClientState defines a client state with an additional client
          identifier field.
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryChannelClientStateResponse is the Response type for the
      Query/QueryChannelClientState RPC method
  ibc.core.channel.v1.QueryChannelConsensusStateResponse:
    type: object
    properties:
      consensus_state:
        type: object
        properties:
          type_url:
            type: string
            description: >-
              A URL/resource name that uniquely identifies the type of the
              serialized

              protocol buffer message. This string must contain at least

              one "/" character. The last segment of the URL's path must
              represent

              the fully qualified name of the type (as in

              `path/google.protobuf.Duration`). The name should be in a
              canonical form

              (e.g., leading "." is not accepted).


              In practice, teams usually precompile into the binary all types
              that they

              expect it to use in the context of Any. However, for URLs which
              use the

              scheme `http`, `https`, or no scheme, one can optionally set up a
              type

              server that maps type URLs to message definitions as follows:


              * If no scheme is provided, `https` is assumed.

              * An HTTP GET on the URL must yield a [google.protobuf.Type][]
                value in binary format, or produce an error.
              * Applications are allowed to cache lookup results based on the
                URL, or have them precompiled into a binary to avoid any
                lookup. Therefore, binary compatibility needs to be preserved
                on changes to types. (Use versioned type names to manage
                breaking changes.)

              Note: this functionality is not currently available in the
              official

              protobuf release, and it is not used for type URLs beginning with

              type.googleapis.com.


              Schemes other than `http`, `https` (or the empty scheme) might be

              used with implementation specific semantics.
          value:
            type: string
            format: byte
            description: >-
              Must be a valid serialized protocol buffer of the above specified
              type.
        description: >-
          `Any` contains an arbitrary serialized protocol buffer message along
          with a

          URL that describes the type of the serialized message.


          Protobuf library provides support to pack/unpack Any values in the
          form

          of utility functions or additional generated methods of the Any type.


          Example 1: Pack and unpack a message in C++.

              Foo foo = ...;
              Any any;
              any.PackFrom(foo);
              ...
              if (any.UnpackTo(&foo)) {
                ...
              }

          Example 2: Pack and unpack a message in Java.

              Foo foo = ...;
              Any any = Any.pack(foo);
              ...
              if (any.is(Foo.class)) {
                foo = any.unpack(Foo.class);
              }

           Example 3: Pack and unpack a message in Python.

              foo = Foo(...)
              any = Any()
              any.Pack(foo)
              ...
              if any.Is(Foo.DESCRIPTOR):
                any.Unpack(foo)
                ...

           Example 4: Pack and unpack a message in Go

               foo := &pb.Foo{...}
               any, err := ptypes.MarshalAny(foo)
               ...
               foo := &pb.Foo{}
               if err := ptypes.UnmarshalAny(any, foo); err != nil {
                 ...
               }

          The pack methods provided by protobuf library will by default use

          'type.googleapis.com/full.type.name' as the type URL and the unpack

          methods only use the fully qualified type name after the last '/'

          in the type URL, for example "foo.bar.com/x/y.z" will yield type

          name "y.z".



          JSON

          ====

          The JSON representation of an `Any` value uses the regular

          representation of the deserialized, embedded message, with an

          additional field `@type` which contains the type URL. Example:

              package google.profile;
              message Person {
                string first_name = 1;
                string last_name = 2;
              }

              {
                "@type": "type.googleapis.com/google.profile.Person",
                "firstName": <string>,
                "lastName": <string>
              }

          If the embedded message type is well-known and has a custom JSON

          representation, that representation will be embedded adding a field

          `value` which holds the custom JSON in addition to the `@type`

          field. Example (for message [google.protobuf.Duration][]):

              {
                "@type": "type.googleapis.com/google.protobuf.Duration",
                "value": "1.212s"
              }
        title: consensus state associated with the channel
      client_id:
        type: string
        title: client ID associated with the consensus state
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryChannelClientStateResponse is the Response type for the
      Query/QueryChannelClientState RPC method
  ibc.core.channel.v1.QueryChannelResponse:
    type: object
    properties:
      channel:
        title: channel associated with the request identifiers
        type: object
        properties:
          state:
            title: current state of the channel end
            type: string
            enum:
              - STATE_UNINITIALIZED_UNSPECIFIED
              - STATE_INIT
              - STATE_TRYOPEN
              - STATE_OPEN
              - STATE_CLOSED
            default: STATE_UNINITIALIZED_UNSPECIFIED
            description: |-
              State defines if a channel is in one of the following states:
              CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.

               - STATE_UNINITIALIZED_UNSPECIFIED: Default State
               - STATE_INIT: A channel has just started the opening handshake.
               - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.
               - STATE_OPEN: A channel has completed the handshake. Open channels are
              ready to send and receive packets.
               - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive
              packets.
          ordering:
            title: whether the channel is ordered or unordered
            type: string
            enum:
              - ORDER_NONE_UNSPECIFIED
              - ORDER_UNORDERED
              - ORDER_ORDERED
            default: ORDER_NONE_UNSPECIFIED
            description: |-
              - ORDER_NONE_UNSPECIFIED: zero-value for channel ordering
               - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in
              which they were sent.
               - ORDER_ORDERED: packets are delivered exactly in the order which they were sent
          counterparty:
            title: counterparty channel end
            type: object
            properties:
              port_id:
                type: string
                description: >-
                  port on the counterparty chain which owns the other end of the
                  channel.
              channel_id:
                type: string
                title: channel end on the counterparty chain
          connection_hops:
            type: array
            items:
              type: string
            title: >-
              list of connection identifiers, in order, along which packets sent
              on

              this channel will travel
          version:
            type: string
            title: 'opaque channel version, which is agreed upon during the handshake'
        description: >-
          Channel defines pipeline for exactly-once packet delivery between
          specific

          modules on separate blockchains, which has at least one end capable of

          sending packets and one end capable of receiving packets.
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    description: >-
      QueryChannelResponse is the response type for the Query/Channel RPC
      method.

      Besides the Channel end, it includes a proof and the height from which the

      proof was retrieved.
  ibc.core.channel.v1.QueryChannelsResponse:
    type: object
    properties:
      channels:
        type: array
        items:
          type: object
          properties:
            state:
              title: current state of the channel end
              type: string
              enum:
                - STATE_UNINITIALIZED_UNSPECIFIED
                - STATE_INIT
                - STATE_TRYOPEN
                - STATE_OPEN
                - STATE_CLOSED
              default: STATE_UNINITIALIZED_UNSPECIFIED
              description: |-
                State defines if a channel is in one of the following states:
                CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.

                 - STATE_UNINITIALIZED_UNSPECIFIED: Default State
                 - STATE_INIT: A channel has just started the opening handshake.
                 - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.
                 - STATE_OPEN: A channel has completed the handshake. Open channels are
                ready to send and receive packets.
                 - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive
                packets.
            ordering:
              title: whether the channel is ordered or unordered
              type: string
              enum:
                - ORDER_NONE_UNSPECIFIED
                - ORDER_UNORDERED
                - ORDER_ORDERED
              default: ORDER_NONE_UNSPECIFIED
              description: |-
                - ORDER_NONE_UNSPECIFIED: zero-value for channel ordering
                 - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in
                which they were sent.
                 - ORDER_ORDERED: packets are delivered exactly in the order which they were sent
            counterparty:
              title: counterparty channel end
              type: object
              properties:
                port_id:
                  type: string
                  description: >-
                    port on the counterparty chain which owns the other end of
                    the channel.
                channel_id:
                  type: string
                  title: channel end on the counterparty chain
            connection_hops:
              type: array
              items:
                type: string
              title: >-
                list of connection identifiers, in order, along which packets
                sent on

                this channel will travel
            version:
              type: string
              title: >-
                opaque channel version, which is agreed upon during the
                handshake
            port_id:
              type: string
              title: port identifier
            channel_id:
              type: string
              title: channel identifier
          description: |-
            IdentifiedChannel defines a channel with additional port and channel
            identifier fields.
        description: list of stored channels of the chain.
      pagination:
        title: pagination response
        type: object
        properties:
          next_key:
            type: string
            format: byte
            title: |-
              next_key is the key to be passed to PageRequest.key to
              query the next page most efficiently
          total:
            type: string
            format: uint64
            title: >-
              total is total number of results available if
              PageRequest.count_total

              was set, its value is undefined otherwise
        description: |-
          PageResponse is to be embedded in gRPC response messages where the
          corresponding request message has used PageRequest.

           message SomeResponse {
                   repeated Bar results = 1;
                   PageResponse page = 2;
           }
      height:
        title: query block height
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    description: >-
      QueryChannelsResponse is the response type for the Query/Channels RPC
      method.
  ibc.core.channel.v1.QueryConnectionChannelsResponse:
    type: object
    properties:
      channels:
        type: array
        items:
          type: object
          properties:
            state:
              title: current state of the channel end
              type: string
              enum:
                - STATE_UNINITIALIZED_UNSPECIFIED
                - STATE_INIT
                - STATE_TRYOPEN
                - STATE_OPEN
                - STATE_CLOSED
              default: STATE_UNINITIALIZED_UNSPECIFIED
              description: |-
                State defines if a channel is in one of the following states:
                CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.

                 - STATE_UNINITIALIZED_UNSPECIFIED: Default State
                 - STATE_INIT: A channel has just started the opening handshake.
                 - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.
                 - STATE_OPEN: A channel has completed the handshake. Open channels are
                ready to send and receive packets.
                 - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive
                packets.
            ordering:
              title: whether the channel is ordered or unordered
              type: string
              enum:
                - ORDER_NONE_UNSPECIFIED
                - ORDER_UNORDERED
                - ORDER_ORDERED
              default: ORDER_NONE_UNSPECIFIED
              description: |-
                - ORDER_NONE_UNSPECIFIED: zero-value for channel ordering
                 - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in
                which they were sent.
                 - ORDER_ORDERED: packets are delivered exactly in the order which they were sent
            counterparty:
              title: counterparty channel end
              type: object
              properties:
                port_id:
                  type: string
                  description: >-
                    port on the counterparty chain which owns the other end of
                    the channel.
                channel_id:
                  type: string
                  title: channel end on the counterparty chain
            connection_hops:
              type: array
              items:
                type: string
              title: >-
                list of connection identifiers, in order, along which packets
                sent on

                this channel will travel
            version:
              type: string
              title: >-
                opaque channel version, which is agreed upon during the
                handshake
            port_id:
              type: string
              title: port identifier
            channel_id:
              type: string
              title: channel identifier
          description: |-
            IdentifiedChannel defines a channel with additional port and channel
            identifier fields.
        description: list of channels associated with a connection.
      pagination:
        title: pagination response
        type: object
        properties:
          next_key:
            type: string
            format: byte
            title: |-
              next_key is the key to be passed to PageRequest.key to
              query the next page most efficiently
          total:
            type: string
            format: uint64
            title: >-
              total is total number of results available if
              PageRequest.count_total

              was set, its value is undefined otherwise
        description: |-
          PageResponse is to be embedded in gRPC response messages where the
          corresponding request message has used PageRequest.

           message SomeResponse {
                   repeated Bar results = 1;
                   PageResponse page = 2;
           }
      height:
        title: query block height
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryConnectionChannelsResponse is the Response type for the
      Query/QueryConnectionChannels RPC method
  ibc.core.channel.v1.QueryNextSequenceReceiveResponse:
    type: object
    properties:
      next_sequence_receive:
        type: string
        format: uint64
        title: next sequence receive number
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QuerySequenceResponse is the request type for the
      Query/QueryNextSequenceReceiveResponse RPC method
  ibc.core.channel.v1.QueryPacketAcknowledgementResponse:
    type: object
    properties:
      acknowledgement:
        type: string
        format: byte
        title: packet associated with the request fields
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryPacketAcknowledgementResponse defines the client query response for a
      packet which also includes a proof and the height from which the
      proof was retrieved
  ibc.core.channel.v1.QueryPacketAcknowledgementsResponse:
    type: object
    properties:
      acknowledgements:
        type: array
        items:
          type: object
          properties:
            port_id:
              type: string
              description: channel port identifier.
            channel_id:
              type: string
              description: channel unique identifier.
            sequence:
              type: string
              format: uint64
              description: packet sequence.
            data:
              type: string
              format: byte
              description: embedded data that represents packet state.
          description: >-
            PacketState defines the generic type necessary to retrieve and store

            packet commitments, acknowledgements, and receipts.

            Caller is responsible for knowing the context necessary to interpret
            this

            state as a commitment, acknowledgement, or a receipt.
      pagination:
        title: pagination response
        type: object
        properties:
          next_key:
            type: string
            format: byte
            title: |-
              next_key is the key to be passed to PageRequest.key to
              query the next page most efficiently
          total:
            type: string
            format: uint64
            title: >-
              total is total number of results available if
              PageRequest.count_total

              was set, its value is undefined otherwise
        description: |-
          PageResponse is to be embedded in gRPC response messages where the
          corresponding request message has used PageRequest.

           message SomeResponse {
                   repeated Bar results = 1;
                   PageResponse page = 2;
           }
      height:
        title: query block height
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryPacketAcknowledgemetsResponse is the request type for the
      Query/QueryPacketAcknowledgements RPC method
  ibc.core.channel.v1.QueryPacketCommitmentResponse:
    type: object
    properties:
      commitment:
        type: string
        format: byte
        title: packet associated with the request fields
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: >-
      QueryPacketCommitmentResponse defines the client query response for a
      packet

      which also includes a proof and the height from which the proof was

      retrieved
  ibc.core.channel.v1.QueryPacketCommitmentsResponse:
    type: object
    properties:
      commitments:
        type: array
        items:
          type: object
          properties:
            port_id:
              type: string
              description: channel port identifier.
            channel_id:
              type: string
              description: channel unique identifier.
            sequence:
              type: string
              format: uint64
              description: packet sequence.
            data:
              type: string
              format: byte
              description: embedded data that represents packet state.
          description: >-
            PacketState defines the generic type necessary to retrieve and store

            packet commitments, acknowledgements, and receipts.

            Caller is responsible for knowing the context necessary to interpret
            this

            state as a commitment, acknowledgement, or a receipt.
      pagination:
        title: pagination response
        type: object
        properties:
          next_key:
            type: string
            format: byte
            title: |-
              next_key is the key to be passed to PageRequest.key to
              query the next page most efficiently
          total:
            type: string
            format: uint64
            title: >-
              total is total number of results available if
              PageRequest.count_total

              was set, its value is undefined otherwise
        description: |-
          PageResponse is to be embedded in gRPC response messages where the
          corresponding request message has used PageRequest.

           message SomeResponse {
                   repeated Bar results = 1;
                   PageResponse page = 2;
           }
      height:
        title: query block height
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryPacketCommitmentsResponse is the request type for the
      Query/QueryPacketCommitments RPC method
  ibc.core.channel.v1.QueryPacketReceiptResponse:
    type: object
    properties:
      received:
        type: boolean
        format: boolean
        title: success flag for if receipt exists
      proof:
        type: string
        format: byte
        title: merkle proof of existence
      proof_height:
        title: height at which the proof was retrieved
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: >-
      QueryPacketReceiptResponse defines the client query response for a packet

      receipt which also includes a proof, and the height from which the proof
      was

      retrieved
  ibc.core.channel.v1.QueryUnreceivedAcksResponse:
    type: object
    properties:
      sequences:
        type: array
        items:
          type: string
          format: uint64
        title: list of unreceived acknowledgement sequences
      height:
        title: query block height
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryUnreceivedAcksResponse is the response type for the
      Query/UnreceivedAcks RPC method
  ibc.core.channel.v1.QueryUnreceivedPacketsResponse:
    type: object
    properties:
      sequences:
        type: array
        items:
          type: string
          format: uint64
        title: list of unreceived packet sequences
      height:
        title: query block height
        type: object
        properties:
          revision_number:
            type: string
            format: uint64
            title: the revision that the client is currently on
          revision_height:
            type: string
            format: uint64
            title: the height within the given revision
        description: >-
          Normally the RevisionHeight is incremented at each height while
          keeping

          RevisionNumber the same. However some consensus algorithms may choose
          to

          reset the height in certain conditions e.g. hard forks, state-machine

          breaking changes In these cases, the RevisionNumber is incremented so
          that

          height continues to be monitonically increasing even as the
          RevisionHeight

          gets reset
    title: |-
      QueryUnreceivedPacketsResponse is the response type for the
      Query/UnreceivedPacketCommitments RPC method
  ibc.core.channel.v1.State:
    type: string
    enum:
      - STATE_UNINITIALIZED_UNSPECIFIED
      - STATE_INIT
      - STATE_TRYOPEN
      - STATE_OPEN
      - STATE_CLOSED
    default: STATE_UNINITIALIZED_UNSPECIFIED
    description: |-
      State defines if a channel is in one of the following states:
      CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.

       - STATE_UNINITIALIZED_UNSPECIFIED: Default State
       - STATE_INIT: A channel has just started the opening handshake.
       - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.
       - STATE_OPEN: A channel has completed the handshake. Open channels are
      ready to send and receive packets.
       - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive
      packets.
