// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Generated by the Codegen C++ plugin.
// If you make any local changes, they will be lost.
// source: google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto

#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_MANAGEDKAFKA_SCHEMAREGISTRY_V1_MANAGED_SCHEMA_REGISTRY_CLIENT_H
#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_MANAGEDKAFKA_SCHEMAREGISTRY_V1_MANAGED_SCHEMA_REGISTRY_CLIENT_H

#include "google/cloud/managedkafka/schemaregistry/v1/managed_schema_registry_connection.h"
#include "google/cloud/future.h"
#include "google/cloud/options.h"
#include "google/cloud/polling_policy.h"
#include "google/cloud/status_or.h"
#include "google/cloud/version.h"
#include <map>
#include <memory>
#include <string>

namespace google {
namespace cloud {
namespace managedkafka_schemaregistry_v1 {
GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN

///
/// SchemaRegistry is a service that allows users to manage schemas for their
/// Kafka clusters. It provides APIs to register, list, and delete schemas, as
/// well as to get the schema for a given schema id or a given version id under
/// a subject, to update the global or subject-specific compatibility mode, and
/// to check the compatibility of a schema against a subject or a version. The
/// main resource hierarchy is as follows:
///
/// * SchemaRegistry
/// * SchemaRegistry/Context
/// * SchemaRegistry/Context/Schema
/// * SchemaRegistry/Context/Subject
/// * SchemaRegistry/Context/Subject/Version
/// * SchemaRegistry/Config
/// * SchemaRegistry/Mode
///
/// **SchemaRegistry** is the root resource to represent a schema registry
/// instance. A customer can have multiple schema registry instances in a
/// project.
///
/// **Context** is a context resource that represents a group of
/// schemas, subjects and versions. A schema registry instance can have multiple
/// contexts and always has a 'default' context. Contexts are independent of
/// each other. Context is optional and if not specified, it falls back to the
/// 'default' context.
///
/// **Schema** is a schema resource that represents a unique schema in a context
/// of a schema registry instance. Each schema has a unique schema id, and can
/// be referenced by a version of a subject.
///
/// **Subject** refers to the name under which the schema is registered. A
/// typical subject is the Kafka topic name. A schema registry instance can have
/// multiple subjects.
///
/// **Version** represents a version of a subject. A subject can have multiple
/// versions. Creation of new version of a subject is guarded by the
/// compatibility mode configured globally or for the subject specifically.
///
/// **Config** represents a config at global level cross all registry
/// instances or at subject level. Currently, only compatibility is supported in
/// config.
///
/// **Mode** represents the mode of a schema registry or a specific subject.
/// Three modes are supported:
/// * READONLY: The schema registry is in read-only mode, no write operations
/// allowed..
/// * READWRITE: The schema registry is in read-write mode, which allows limited
/// write operations on the schema.
/// * IMPORT: The schema registry is in import mode, which allows more editing
/// operations on the schema for data importing purposes.
///
/// @par Equality
///
/// Instances of this class created via copy-construction or copy-assignment
/// always compare equal. Instances created with equal
/// `std::shared_ptr<*Connection>` objects compare equal. Objects that compare
/// equal share the same underlying resources.
///
/// @par Performance
///
/// Creating a new instance of this class is a relatively expensive operation,
/// new objects establish new connections to the service. In contrast,
/// copy-construction, move-construction, and the corresponding assignment
/// operations are relatively efficient as the copies share all underlying
/// resources.
///
/// @par Thread Safety
///
/// Concurrent access to different instances of this class, even if they compare
/// equal, is guaranteed to work. Two or more threads operating on the same
/// instance of this class is not guaranteed to work. Since copy-construction
/// and move-construction is a relatively efficient operation, consider using
/// such a copy when using this class from multiple threads.
///
class ManagedSchemaRegistryClient {
 public:
  explicit ManagedSchemaRegistryClient(
      std::shared_ptr<ManagedSchemaRegistryConnection> connection,
      Options opts = {});
  ~ManagedSchemaRegistryClient();

  ///@{
  /// @name Copy and move support
  ManagedSchemaRegistryClient(ManagedSchemaRegistryClient const&) = default;
  ManagedSchemaRegistryClient& operator=(ManagedSchemaRegistryClient const&) =
      default;
  ManagedSchemaRegistryClient(ManagedSchemaRegistryClient&&) = default;
  ManagedSchemaRegistryClient& operator=(ManagedSchemaRegistryClient&&) =
      default;
  ///@}

  ///@{
  /// @name Equality
  friend bool operator==(ManagedSchemaRegistryClient const& a,
                         ManagedSchemaRegistryClient const& b) {
    return a.connection_ == b.connection_;
  }
  friend bool operator!=(ManagedSchemaRegistryClient const& a,
                         ManagedSchemaRegistryClient const& b) {
    return !(a == b);
  }
  ///@}

  // clang-format off
  ///
  /// Get the schema registry instance.
  ///
  /// @param name  Required. The name of the schema registry instance to return. Structured
  ///  like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaRegistry])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.GetSchemaRegistryRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L402}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaRegistry]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L31}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaRegistry>
  GetSchemaRegistry(std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Get the schema registry instance.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.GetSchemaRegistryRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaRegistry])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.GetSchemaRegistryRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L402}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaRegistry]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L31}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaRegistry>
  GetSchemaRegistry(google::cloud::managedkafka::schemaregistry::v1::
                        GetSchemaRegistryRequest const& request,
                    Options opts = {});

  // clang-format off
  ///
  /// List schema registries.
  ///
  /// @param parent  Required. The parent whose schema registry instances are to be listed.
  ///  Structured like: `projects/{project}/locations/{location}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.ListSchemaRegistriesResponse])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSchemaRegistriesRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L415}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSchemaRegistriesResponse]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L425}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::
               ListSchemaRegistriesResponse>
  ListSchemaRegistries(std::string const& parent, Options opts = {});

  // clang-format off
  ///
  /// List schema registries.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.ListSchemaRegistriesRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.ListSchemaRegistriesResponse])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSchemaRegistriesRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L415}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSchemaRegistriesResponse]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L425}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::
               ListSchemaRegistriesResponse>
  ListSchemaRegistries(google::cloud::managedkafka::schemaregistry::v1::
                           ListSchemaRegistriesRequest const& request,
                       Options opts = {});

  // clang-format off
  ///
  /// Create a schema registry instance.
  ///
  /// @param parent  Required. The parent whose schema registry instance is to be created.
  ///  Structured like: `projects/{project}/locations/{location}`
  /// @param schema_registry  Required. The schema registry instance to create.
  ///  The name field is ignored.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaRegistry])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.CreateSchemaRegistryRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L431}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaRegistry]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L31}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaRegistry>
  CreateSchemaRegistry(
      std::string const& parent,
      google::cloud::managedkafka::schemaregistry::v1::SchemaRegistry const&
          schema_registry,
      Options opts = {});

  // clang-format off
  ///
  /// Create a schema registry instance.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.CreateSchemaRegistryRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaRegistry])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.CreateSchemaRegistryRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L431}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaRegistry]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L31}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaRegistry>
  CreateSchemaRegistry(google::cloud::managedkafka::schemaregistry::v1::
                           CreateSchemaRegistryRequest const& request,
                       Options opts = {});

  // clang-format off
  ///
  /// Delete a schema registry instance.
  ///
  /// @param name  Required. The name of the schema registry instance to delete. Structured
  ///  like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return a [`Status`] object. If the request failed, the
  ///     status contains the details of the failure.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.DeleteSchemaRegistryRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L451}
  ///
  // clang-format on
  Status DeleteSchemaRegistry(std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Delete a schema registry instance.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.DeleteSchemaRegistryRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return a [`Status`] object. If the request failed, the
  ///     status contains the details of the failure.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.DeleteSchemaRegistryRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L451}
  ///
  // clang-format on
  Status DeleteSchemaRegistry(google::cloud::managedkafka::schemaregistry::v1::
                                  DeleteSchemaRegistryRequest const& request,
                              Options opts = {});

  // clang-format off
  ///
  /// Get the context.
  ///
  /// @param name  Required. The name of the context to return. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.Context])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.Context]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L57}
  /// [google.cloud.managedkafka.schemaregistry.v1.GetContextRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L464}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::Context> GetContext(
      std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Get the context.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.GetContextRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.Context])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.Context]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L57}
  /// [google.cloud.managedkafka.schemaregistry.v1.GetContextRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L464}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::Context> GetContext(
      google::cloud::managedkafka::schemaregistry::v1::GetContextRequest const&
          request,
      Options opts = {});

  // clang-format off
  ///
  /// List contexts for a schema registry.
  ///
  /// @param parent  Required. The parent of the contexts. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListContextsRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L476}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListContexts(std::string const& parent,
                                               Options opts = {});

  // clang-format off
  ///
  /// List contexts for a schema registry.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.ListContextsRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListContextsRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L476}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListContexts(
      google::cloud::managedkafka::schemaregistry::v1::
          ListContextsRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// Get the schema for the given schema id.
  ///
  /// @param name  Required. The name of the schema to return. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.Schema])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.GetSchemaRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L488}
  /// [google.cloud.managedkafka.schemaregistry.v1.Schema]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L83}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::Schema> GetSchema(
      std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Get the schema for the given schema id.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.GetSchemaRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.Schema])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.GetSchemaRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L488}
  /// [google.cloud.managedkafka.schemaregistry.v1.Schema]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L83}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::Schema> GetSchema(
      google::cloud::managedkafka::schemaregistry::v1::GetSchemaRequest const&
          request,
      Options opts = {});

  // clang-format off
  ///
  /// Get the schema string for the given schema id.
  /// The response will be the schema string.
  ///
  /// @param name  Required. The name of the schema to return. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.GetSchemaRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L488}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> GetRawSchema(std::string const& name,
                                               Options opts = {});

  // clang-format off
  ///
  /// Get the schema string for the given schema id.
  /// The response will be the schema string.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.GetSchemaRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.GetSchemaRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L488}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> GetRawSchema(
      google::cloud::managedkafka::schemaregistry::v1::GetSchemaRequest const&
          request,
      Options opts = {});

  // clang-format off
  ///
  /// List the schema versions for the given schema id.
  /// The response will be an array of subject-version pairs as:
  /// [{"subject":"subject1", "version":1}, {"subject":"subject2", "version":2}].
  ///
  /// @param parent  Required. The schema whose schema versions are to be listed. Structured
  ///  like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/schemas/ids/{schema}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSchemaVersionsRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L516}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListSchemaVersions(std::string const& parent,
                                                     Options opts = {});

  // clang-format off
  ///
  /// List the schema versions for the given schema id.
  /// The response will be an array of subject-version pairs as:
  /// [{"subject":"subject1", "version":1}, {"subject":"subject2", "version":2}].
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.ListSchemaVersionsRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSchemaVersionsRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L516}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListSchemaVersions(
      google::cloud::managedkafka::schemaregistry::v1::
          ListSchemaVersionsRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// List the supported schema types.
  /// The response will be an array of schema types.
  ///
  /// @param parent  Required. The parent schema registry whose schema types are to be listed.
  ///  Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSchemaTypesRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L505}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListSchemaTypes(std::string const& parent,
                                                  Options opts = {});

  // clang-format off
  ///
  /// List the supported schema types.
  /// The response will be an array of schema types.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.ListSchemaTypesRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSchemaTypesRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L505}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListSchemaTypes(
      google::cloud::managedkafka::schemaregistry::v1::
          ListSchemaTypesRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// List subjects in the schema registry.
  /// The response will be an array of subject names.
  ///
  /// @param parent  Required. The parent schema registry/context whose subjects are to be
  ///  listed. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}`
  /// @param subject_prefix  Optional. The context to filter the subjects by, in the format of
  ///  `:.{context}:`. If unset, all subjects in the registry are returned. Set to
  ///  empty string or add as
  ///  '?subjectPrefix=' at the end of this request to list subjects in the
  ///  default context.
  /// @param deleted  Optional. If true, the response will include soft-deleted subjects. The
  ///  default is false.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSubjectsRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L538}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListSubjects(
      std::string const& parent, std::string const& subject_prefix,
      bool deleted, Options opts = {});

  // clang-format off
  ///
  /// List subjects in the schema registry.
  /// The response will be an array of subject names.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.ListSubjectsRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSubjectsRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L538}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListSubjects(
      google::cloud::managedkafka::schemaregistry::v1::
          ListSubjectsRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// List subjects which reference a particular schema id.
  /// The response will be an array of subject names.
  ///
  /// @param parent  Required. The schema resource whose associated subjects are to be listed.
  ///  Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/schemas/ids/{schema}`
  /// @param subject  Optional. The subject to filter the subjects by.
  /// @param deleted  Optional. If true, the response will include soft-deleted subjects. The
  ///  default is false.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSubjectsBySchemaIdRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L562}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListSubjectsBySchemaId(
      std::string const& parent, std::string const& subject, bool deleted,
      Options opts = {});

  // clang-format off
  ///
  /// List subjects which reference a particular schema id.
  /// The response will be an array of subject names.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.ListSubjectsBySchemaIdRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListSubjectsBySchemaIdRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L562}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListSubjectsBySchemaId(
      google::cloud::managedkafka::schemaregistry::v1::
          ListSubjectsBySchemaIdRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// Delete a subject.
  /// The response will be an array of versions of the deleted subject.
  ///
  /// @param name  Required. The name of the subject to delete. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/subjects/{subject}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.DeleteSubjectRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L600}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> DeleteSubject(std::string const& name,
                                                Options opts = {});

  // clang-format off
  ///
  /// Delete a subject.
  /// The response will be an array of versions of the deleted subject.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.DeleteSubjectRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.DeleteSubjectRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L600}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> DeleteSubject(
      google::cloud::managedkafka::schemaregistry::v1::
          DeleteSubjectRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// Lookup a schema under the specified subject.
  ///
  /// @param parent  Required. The subject to lookup the schema in. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/subjects/{subject}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}`
  /// @param schema  Required. The schema payload
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaVersion])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.LookupVersionRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L687}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaVersion]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L163}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaVersion>
  LookupVersion(std::string const& parent, std::string const& schema,
                Options opts = {});

  // clang-format off
  ///
  /// Lookup a schema under the specified subject.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.LookupVersionRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaVersion])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.LookupVersionRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L687}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaVersion]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L163}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaVersion>
  LookupVersion(google::cloud::managedkafka::schemaregistry::v1::
                    LookupVersionRequest const& request,
                Options opts = {});

  // clang-format off
  ///
  /// Get a versioned schema (schema with subject/version) of a subject.
  ///
  /// @param name  Required. The name of the subject to return versions. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/subjects/{subject}/versions/{version}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}/versions/{version}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaVersion])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.GetVersionRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L621}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaVersion]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L163}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaVersion>
  GetVersion(std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Get a versioned schema (schema with subject/version) of a subject.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.GetVersionRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaVersion])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.GetVersionRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L621}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaVersion]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L163}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaVersion>
  GetVersion(
      google::cloud::managedkafka::schemaregistry::v1::GetVersionRequest const&
          request,
      Options opts = {});

  // clang-format off
  ///
  /// Get the schema string only for a version of a subject.
  /// The response will be the schema string.
  ///
  /// @param name  Required. The name of the subject to return versions. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/subjects/{subject}/versions/{version}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}/versions/{version}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.GetVersionRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L621}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> GetRawSchemaVersion(std::string const& name,
                                                      Options opts = {});

  // clang-format off
  ///
  /// Get the schema string only for a version of a subject.
  /// The response will be the schema string.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.GetVersionRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.GetVersionRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L621}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> GetRawSchemaVersion(
      google::cloud::managedkafka::schemaregistry::v1::GetVersionRequest const&
          request,
      Options opts = {});

  // clang-format off
  ///
  /// Get all versions of a subject.
  /// The response will be an array of versions of the subject.
  ///
  /// @param parent  Required. The subject whose versions are to be listed. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/subjects/{subject}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListVersionsRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L582}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListVersions(std::string const& parent,
                                               Options opts = {});

  // clang-format off
  ///
  /// Get all versions of a subject.
  /// The response will be an array of versions of the subject.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.ListVersionsRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListVersionsRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L582}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListVersions(
      google::cloud::managedkafka::schemaregistry::v1::
          ListVersionsRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// Register a new version under a given subject with the given schema.
  ///
  /// @param parent  Required. The subject to create the version for. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/subjects/{subject}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}`
  /// @param version  Optional. The version to create. It is optional. If not specified, the
  ///  version will be created with the max version ID of the subject increased
  ///  by 1. If the version ID is specified, it will be used as the new version ID
  ///  and must not be used by an existing version of the subject.
  /// @param id  Optional. The schema ID of the schema. If not specified, the schema ID will
  ///  be generated by the server. If the schema ID is specified, it must not be
  ///  used by an existing schema that is different from the schema to be created.
  /// @param schema_type  Optional. The type of the schema. It is optional. If not specified, the
  ///  schema type will be AVRO.
  /// @param schema  Required. The schema payload
  /// @param references  Optional. The schema references used by the schema.
  /// @param normalize  Optional. If true, the schema will be normalized before being stored. The
  ///  default is false.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.CreateVersionResponse])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.CreateVersionRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L640}
  /// [google.cloud.managedkafka.schemaregistry.v1.CreateVersionResponse]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L681}
  ///
  // clang-format on
  StatusOr<
      google::cloud::managedkafka::schemaregistry::v1::CreateVersionResponse>
  CreateVersion(
      std::string const& parent, std::int32_t version, std::int32_t id,
      google::cloud::managedkafka::schemaregistry::v1::Schema::SchemaType
          schema_type,
      std::string const& schema,
      std::vector<google::cloud::managedkafka::schemaregistry::v1::Schema::
                      SchemaReference> const& references,
      bool normalize, Options opts = {});

  // clang-format off
  ///
  /// Register a new version under a given subject with the given schema.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.CreateVersionRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.CreateVersionResponse])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.CreateVersionRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L640}
  /// [google.cloud.managedkafka.schemaregistry.v1.CreateVersionResponse]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L681}
  ///
  // clang-format on
  StatusOr<
      google::cloud::managedkafka::schemaregistry::v1::CreateVersionResponse>
  CreateVersion(google::cloud::managedkafka::schemaregistry::v1::
                    CreateVersionRequest const& request,
                Options opts = {});

  // clang-format off
  ///
  /// Delete a version of a subject.
  /// The response will be the deleted version id.
  ///
  /// @param name  Required. The name of the subject version to delete. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/subjects/{subject}/versions/{version}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}/versions/{version}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.DeleteVersionRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L721}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> DeleteVersion(std::string const& name,
                                                Options opts = {});

  // clang-format off
  ///
  /// Delete a version of a subject.
  /// The response will be the deleted version id.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.DeleteVersionRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.DeleteVersionRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L721}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> DeleteVersion(
      google::cloud::managedkafka::schemaregistry::v1::
          DeleteVersionRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// Get a list of IDs of schemas that reference the schema with the given
  /// subject and version.
  ///
  /// @param parent  Required. The version to list referenced by. Structured like:
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/subjects/{subject}/versions/{version}`
  ///  or
  ///  `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}/versions/{version}`
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListReferencedSchemasRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L742}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListReferencedSchemas(
      std::string const& parent, Options opts = {});

  // clang-format off
  ///
  /// Get a list of IDs of schemas that reference the schema with the given
  /// subject and version.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.ListReferencedSchemasRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.api.HttpBody])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.api.HttpBody]: @googleapis_reference_link{google/api/httpbody.proto#L70}
  /// [google.cloud.managedkafka.schemaregistry.v1.ListReferencedSchemasRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L742}
  ///
  // clang-format on
  StatusOr<google::api::HttpBody> ListReferencedSchemas(
      google::cloud::managedkafka::schemaregistry::v1::
          ListReferencedSchemasRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// Check compatibility of a schema with all versions or a specific version of
  /// a subject.
  ///
  /// @param name  Required. The name of the resource to check compatibility for. The format
  ///  is either of following:
  ///  * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/compatibility/subjects/*/versions: Check compatibility with one or
  ///    more versions of the specified subject.
  ///  * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/compatibility/subjects/{subject}/versions/{version}: Check
  ///    compatibility with a specific version of the subject.
  /// @param schema  Required. The schema payload
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.CheckCompatibilityResponse])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.CheckCompatibilityRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L756}
  /// [google.cloud.managedkafka.schemaregistry.v1.CheckCompatibilityResponse]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L785}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::
               CheckCompatibilityResponse>
  CheckCompatibility(std::string const& name, std::string const& schema,
                     Options opts = {});

  // clang-format off
  ///
  /// Check compatibility of a schema with all versions or a specific version of
  /// a subject.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.CheckCompatibilityRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.CheckCompatibilityResponse])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.CheckCompatibilityRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L756}
  /// [google.cloud.managedkafka.schemaregistry.v1.CheckCompatibilityResponse]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L785}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::
               CheckCompatibilityResponse>
  CheckCompatibility(google::cloud::managedkafka::schemaregistry::v1::
                         CheckCompatibilityRequest const& request,
                     Options opts = {});

  // clang-format off
  ///
  /// Get schema config at global level or for a subject.
  ///
  /// @param name  Required. The resource name to get the config for. It can be either of
  ///  following:
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/config: Get config at global level.
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/config/{subject}: Get config for a specific subject.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaConfig])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.GetSchemaConfigRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L795}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaConfig]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L201}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaConfig>
  GetSchemaConfig(std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Get schema config at global level or for a subject.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.GetSchemaConfigRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaConfig])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.GetSchemaConfigRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L795}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaConfig]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L201}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaConfig>
  GetSchemaConfig(google::cloud::managedkafka::schemaregistry::v1::
                      GetSchemaConfigRequest const& request,
                  Options opts = {});

  // clang-format off
  ///
  /// Update config at global level or for a subject.
  /// Creates a SchemaSubject-level SchemaConfig if it does not exist.
  ///
  /// @param name  Required. The resource name to update the config for. It can be either of
  ///  following:
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/config: Update config at global level.
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/config/{subject}: Update config for a specific subject.
  /// @param compatibility  Required. The compatibility type of the schemas.
  ///  Cannot be unset for a SchemaRegistry-level SchemaConfig.
  ///  If unset on a SchemaSubject-level SchemaConfig, removes the compatibility
  ///  field for the SchemaConfig.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaConfig])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaConfig]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L201}
  /// [google.cloud.managedkafka.schemaregistry.v1.UpdateSchemaConfigRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L815}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaConfig>
  UpdateSchemaConfig(std::string const& name,
                     google::cloud::managedkafka::schemaregistry::v1::
                         SchemaConfig::CompatibilityType compatibility,
                     Options opts = {});

  // clang-format off
  ///
  /// Update config at global level or for a subject.
  /// Creates a SchemaSubject-level SchemaConfig if it does not exist.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.UpdateSchemaConfigRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaConfig])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaConfig]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L201}
  /// [google.cloud.managedkafka.schemaregistry.v1.UpdateSchemaConfigRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L815}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaConfig>
  UpdateSchemaConfig(google::cloud::managedkafka::schemaregistry::v1::
                         UpdateSchemaConfigRequest const& request,
                     Options opts = {});

  // clang-format off
  ///
  /// Delete schema config for a subject.
  ///
  /// @param name  Required. The resource name of subject to delete the config for. The format
  ///  is
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/config/{subject}
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaConfig])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.DeleteSchemaConfigRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L842}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaConfig]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L201}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaConfig>
  DeleteSchemaConfig(std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Delete schema config for a subject.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.DeleteSchemaConfigRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaConfig])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.DeleteSchemaConfigRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L842}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaConfig]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L201}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaConfig>
  DeleteSchemaConfig(google::cloud::managedkafka::schemaregistry::v1::
                         DeleteSchemaConfigRequest const& request,
                     Options opts = {});

  // clang-format off
  ///
  /// Get mode at global level or for a subject.
  ///
  /// @param name  Required. The resource name of the mode. The format is
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/mode/{subject}: mode for a schema registry, or
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/mode/{subject}: mode for a specific subject in a specific context
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaMode])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.GetSchemaModeRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L855}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaMode]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L264}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaMode>
  GetSchemaMode(std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Get mode at global level or for a subject.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.GetSchemaModeRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaMode])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.GetSchemaModeRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L855}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaMode]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L264}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaMode>
  GetSchemaMode(google::cloud::managedkafka::schemaregistry::v1::
                    GetSchemaModeRequest const& request,
                Options opts = {});

  // clang-format off
  ///
  /// Update mode at global level or for a subject.
  ///
  /// @param name  Required. The resource name of the mode. The format is
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/mode/{subject}: mode for a schema registry, or
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/mode/{subject}: mode for a specific subject in a specific context
  /// @param mode  Required. The mode type.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaMode])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaMode]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L264}
  /// [google.cloud.managedkafka.schemaregistry.v1.UpdateSchemaModeRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L868}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaMode>
  UpdateSchemaMode(
      std::string const& name,
      google::cloud::managedkafka::schemaregistry::v1::SchemaMode::ModeType
          mode,
      Options opts = {});

  // clang-format off
  ///
  /// Update mode at global level or for a subject.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.UpdateSchemaModeRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaMode])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaMode]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L264}
  /// [google.cloud.managedkafka.schemaregistry.v1.UpdateSchemaModeRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L868}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaMode>
  UpdateSchemaMode(google::cloud::managedkafka::schemaregistry::v1::
                       UpdateSchemaModeRequest const& request,
                   Options opts = {});

  // clang-format off
  ///
  /// Delete schema mode for a subject.
  ///
  /// @param name  Required. The resource name of subject to delete the mode for. The format
  ///  is
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/mode/{subject}
  ///    * projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}/mode/{subject}
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaMode])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.DeleteSchemaModeRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L884}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaMode]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L264}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaMode>
  DeleteSchemaMode(std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Delete schema mode for a subject.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.managedkafka.schemaregistry.v1.DeleteSchemaModeRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.managedkafka.schemaregistry.v1.SchemaMode])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.managedkafka.schemaregistry.v1.DeleteSchemaModeRequest]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry.proto#L884}
  /// [google.cloud.managedkafka.schemaregistry.v1.SchemaMode]: @googleapis_reference_link{google/cloud/managedkafka/schemaregistry/v1/schema_registry_resources.proto#L264}
  ///
  // clang-format on
  StatusOr<google::cloud::managedkafka::schemaregistry::v1::SchemaMode>
  DeleteSchemaMode(google::cloud::managedkafka::schemaregistry::v1::
                       DeleteSchemaModeRequest const& request,
                   Options opts = {});

  // clang-format off
  ///
  /// Lists information about the supported locations for this service.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.location.ListLocationsRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return a [StreamRange](@ref google::cloud::StreamRange)
  ///     to iterate of the results. See the documentation of this type for
  ///     details. In brief, this class has `begin()` and `end()` member
  ///     functions returning a iterator class meeting the
  ///     [input iterator requirements]. The value type for this iterator is a
  ///     [`StatusOr`] as the iteration may fail even after some values are
  ///     retrieved successfully, for example, if there is a network disconnect.
  ///     An empty set of results does not indicate an error, it indicates
  ///     that there are no resources meeting the request criteria.
  ///     On a successful iteration the `StatusOr<T>` contains elements of type
  ///     [google.cloud.location.Location], or rather,
  ///     the C++ class generated by Protobuf from that type. Please consult the
  ///     Protobuf documentation for details on the [Protobuf mapping rules].
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.location.ListLocationsRequest]: @googleapis_reference_link{google/cloud/location/locations.proto#L58}
  /// [google.cloud.location.Location]: @googleapis_reference_link{google/cloud/location/locations.proto#L88}
  ///
  // clang-format on
  StreamRange<google::cloud::location::Location> ListLocations(
      google::cloud::location::ListLocationsRequest request, Options opts = {});

  // clang-format off
  ///
  /// Gets information about a location.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.cloud.location.GetLocationRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.cloud.location.Location])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.cloud.location.GetLocationRequest]: @googleapis_reference_link{google/cloud/location/locations.proto#L82}
  /// [google.cloud.location.Location]: @googleapis_reference_link{google/cloud/location/locations.proto#L88}
  ///
  // clang-format on
  StatusOr<google::cloud::location::Location> GetLocation(
      google::cloud::location::GetLocationRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// Lists operations that match the specified filter in the request. If the
  /// server doesn't support this method, it returns `UNIMPLEMENTED`.
  ///
  /// @param name  The name of the operation's parent resource.
  /// @param filter  The standard list filter.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return a [StreamRange](@ref google::cloud::StreamRange)
  ///     to iterate of the results. See the documentation of this type for
  ///     details. In brief, this class has `begin()` and `end()` member
  ///     functions returning a iterator class meeting the
  ///     [input iterator requirements]. The value type for this iterator is a
  ///     [`StatusOr`] as the iteration may fail even after some values are
  ///     retrieved successfully, for example, if there is a network disconnect.
  ///     An empty set of results does not indicate an error, it indicates
  ///     that there are no resources meeting the request criteria.
  ///     On a successful iteration the `StatusOr<T>` contains elements of type
  ///     [google.longrunning.Operation], or rather,
  ///     the C++ class generated by Protobuf from that type. Please consult the
  ///     Protobuf documentation for details on the [Protobuf mapping rules].
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.longrunning.ListOperationsRequest]: @googleapis_reference_link{google/longrunning/operations.proto#L167}
  /// [google.longrunning.Operation]: @googleapis_reference_link{google/longrunning/operations.proto#L121}
  ///
  // clang-format on
  StreamRange<google::longrunning::Operation> ListOperations(
      std::string const& name, std::string const& filter, Options opts = {});

  // clang-format off
  ///
  /// Lists operations that match the specified filter in the request. If the
  /// server doesn't support this method, it returns `UNIMPLEMENTED`.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.longrunning.ListOperationsRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return a [StreamRange](@ref google::cloud::StreamRange)
  ///     to iterate of the results. See the documentation of this type for
  ///     details. In brief, this class has `begin()` and `end()` member
  ///     functions returning a iterator class meeting the
  ///     [input iterator requirements]. The value type for this iterator is a
  ///     [`StatusOr`] as the iteration may fail even after some values are
  ///     retrieved successfully, for example, if there is a network disconnect.
  ///     An empty set of results does not indicate an error, it indicates
  ///     that there are no resources meeting the request criteria.
  ///     On a successful iteration the `StatusOr<T>` contains elements of type
  ///     [google.longrunning.Operation], or rather,
  ///     the C++ class generated by Protobuf from that type. Please consult the
  ///     Protobuf documentation for details on the [Protobuf mapping rules].
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.longrunning.ListOperationsRequest]: @googleapis_reference_link{google/longrunning/operations.proto#L167}
  /// [google.longrunning.Operation]: @googleapis_reference_link{google/longrunning/operations.proto#L121}
  ///
  // clang-format on
  StreamRange<google::longrunning::Operation> ListOperations(
      google::longrunning::ListOperationsRequest request, Options opts = {});

  // clang-format off
  ///
  /// Gets the latest state of a long-running operation.  Clients can use this
  /// method to poll the operation result at intervals as recommended by the API
  /// service.
  ///
  /// @param name  The name of the operation resource.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.longrunning.Operation])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.longrunning.GetOperationRequest]: @googleapis_reference_link{google/longrunning/operations.proto#L160}
  /// [google.longrunning.Operation]: @googleapis_reference_link{google/longrunning/operations.proto#L121}
  ///
  // clang-format on
  StatusOr<google::longrunning::Operation> GetOperation(std::string const& name,
                                                        Options opts = {});

  // clang-format off
  ///
  /// Gets the latest state of a long-running operation.  Clients can use this
  /// method to poll the operation result at intervals as recommended by the API
  /// service.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.longrunning.GetOperationRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return the result of the RPC. The response message type
  ///     ([google.longrunning.Operation])
  ///     is mapped to a C++ class using the [Protobuf mapping rules].
  ///     If the request fails, the [`StatusOr`] contains the error details.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.longrunning.GetOperationRequest]: @googleapis_reference_link{google/longrunning/operations.proto#L160}
  /// [google.longrunning.Operation]: @googleapis_reference_link{google/longrunning/operations.proto#L121}
  ///
  // clang-format on
  StatusOr<google::longrunning::Operation> GetOperation(
      google::longrunning::GetOperationRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// Deletes a long-running operation. This method indicates that the client is
  /// no longer interested in the operation result. It does not cancel the
  /// operation. If the server doesn't support this method, it returns
  /// `google.rpc.Code.UNIMPLEMENTED`.
  ///
  /// @param name  The name of the operation resource to be deleted.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return a [`Status`] object. If the request failed, the
  ///     status contains the details of the failure.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.longrunning.DeleteOperationRequest]: @googleapis_reference_link{google/longrunning/operations.proto#L219}
  ///
  // clang-format on
  Status DeleteOperation(std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Deletes a long-running operation. This method indicates that the client is
  /// no longer interested in the operation result. It does not cancel the
  /// operation. If the server doesn't support this method, it returns
  /// `google.rpc.Code.UNIMPLEMENTED`.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.longrunning.DeleteOperationRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return a [`Status`] object. If the request failed, the
  ///     status contains the details of the failure.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.longrunning.DeleteOperationRequest]: @googleapis_reference_link{google/longrunning/operations.proto#L219}
  ///
  // clang-format on
  Status DeleteOperation(
      google::longrunning::DeleteOperationRequest const& request,
      Options opts = {});

  // clang-format off
  ///
  /// Starts asynchronous cancellation on a long-running operation.  The server
  /// makes a best effort to cancel the operation, but success is not
  /// guaranteed.  If the server doesn't support this method, it returns
  /// `google.rpc.Code.UNIMPLEMENTED`.  Clients can use
  /// [Operations.GetOperation][google.longrunning.Operations.GetOperation] or
  /// other methods to check whether the cancellation succeeded or whether the
  /// operation completed despite cancellation. On successful cancellation,
  /// the operation is not deleted; instead, it becomes an operation with
  /// an [Operation.error][google.longrunning.Operation.error] value with a
  /// [google.rpc.Status.code][google.rpc.Status.code] of `1`, corresponding to
  /// `Code.CANCELLED`.
  ///
  /// @param name  The name of the operation resource to be cancelled.
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return a [`Status`] object. If the request failed, the
  ///     status contains the details of the failure.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.longrunning.CancelOperationRequest]: @googleapis_reference_link{google/longrunning/operations.proto#L212}
  /// [google.longrunning.Operation.error]: @googleapis_reference_link{google/longrunning/operations.proto#L144}
  /// [google.longrunning.Operations.GetOperation]: @googleapis_reference_link{google/longrunning/operations.proto#L70}
  /// [google.rpc.Status.code]: @googleapis_reference_link{google/rpc/status.proto#L38}
  ///
  // clang-format on
  Status CancelOperation(std::string const& name, Options opts = {});

  // clang-format off
  ///
  /// Starts asynchronous cancellation on a long-running operation.  The server
  /// makes a best effort to cancel the operation, but success is not
  /// guaranteed.  If the server doesn't support this method, it returns
  /// `google.rpc.Code.UNIMPLEMENTED`.  Clients can use
  /// [Operations.GetOperation][google.longrunning.Operations.GetOperation] or
  /// other methods to check whether the cancellation succeeded or whether the
  /// operation completed despite cancellation. On successful cancellation,
  /// the operation is not deleted; instead, it becomes an operation with
  /// an [Operation.error][google.longrunning.Operation.error] value with a
  /// [google.rpc.Status.code][google.rpc.Status.code] of `1`, corresponding to
  /// `Code.CANCELLED`.
  ///
  /// @param request Unary RPCs, such as the one wrapped by this
  ///     function, receive a single `request` proto message which includes all
  ///     the inputs for the RPC. In this case, the proto message is a
  ///     [google.longrunning.CancelOperationRequest].
  ///     Proto messages are converted to C++ classes by Protobuf, using the
  ///     [Protobuf mapping rules].
  /// @param opts Optional. Override the class-level options, such as retry and
  ///     backoff policies.
  /// @return a [`Status`] object. If the request failed, the
  ///     status contains the details of the failure.
  ///
  /// [Protobuf mapping rules]: https://protobuf.dev/reference/cpp/cpp-generated/
  /// [input iterator requirements]: https://en.cppreference.com/w/cpp/named_req/InputIterator
  /// [`std::string`]: https://en.cppreference.com/w/cpp/string/basic_string
  /// [`future`]: @ref google::cloud::future
  /// [`StatusOr`]: @ref google::cloud::StatusOr
  /// [`Status`]: @ref google::cloud::Status
  /// [google.longrunning.CancelOperationRequest]: @googleapis_reference_link{google/longrunning/operations.proto#L212}
  /// [google.longrunning.Operation.error]: @googleapis_reference_link{google/longrunning/operations.proto#L144}
  /// [google.longrunning.Operations.GetOperation]: @googleapis_reference_link{google/longrunning/operations.proto#L70}
  /// [google.rpc.Status.code]: @googleapis_reference_link{google/rpc/status.proto#L38}
  ///
  // clang-format on
  Status CancelOperation(
      google::longrunning::CancelOperationRequest const& request,
      Options opts = {});

 private:
  std::shared_ptr<ManagedSchemaRegistryConnection> connection_;
  Options options_;
};

GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
}  // namespace managedkafka_schemaregistry_v1
}  // namespace cloud
}  // namespace google

#endif  // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_MANAGEDKAFKA_SCHEMAREGISTRY_V1_MANAGED_SCHEMA_REGISTRY_CLIENT_H
