SchemasClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/schemas/SchemasPaginationBase.h>
#include <aws/schemas/SchemasServiceClientModel.h>
#include <aws/schemas/SchemasWaiter.h>
#include <aws/schemas/Schemas_EXPORTS.h>
 
namespace Aws {
namespace Schemas {
class AWS_SCHEMAS_API SchemasClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<SchemasClient>,
                                      public SchemasPaginationBase<SchemasClient>,
                                      public SchemasWaiter<SchemasClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SchemasClientConfiguration ClientConfigurationType;
  typedef SchemasEndpointProvider EndpointProviderType;
 
  SchemasClient(const Aws::Schemas::SchemasClientConfiguration& clientConfiguration = Aws::Schemas::SchemasClientConfiguration(),
                std::shared_ptr<SchemasEndpointProviderBase> endpointProvider = nullptr);
 
  SchemasClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<SchemasEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Schemas::SchemasClientConfiguration& clientConfiguration = Aws::Schemas::SchemasClientConfiguration());
 
  SchemasClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<SchemasEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Schemas::SchemasClientConfiguration& clientConfiguration = Aws::Schemas::SchemasClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SchemasClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SchemasClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SchemasClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SchemasClient();
 
  virtual Model::CreateDiscovererOutcome CreateDiscoverer(const Model::CreateDiscovererRequest& request) const;
 
  template <typename CreateDiscovererRequestT = Model::CreateDiscovererRequest>
  Model::CreateDiscovererOutcomeCallable CreateDiscovererCallable(const CreateDiscovererRequestT& request) const {
    return SubmitCallable(&SchemasClient::CreateDiscoverer, request);
  }
 
  template <typename CreateDiscovererRequestT = Model::CreateDiscovererRequest>
  void CreateDiscovererAsync(const CreateDiscovererRequestT& request, const CreateDiscovererResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::CreateDiscoverer, request, handler, context);
  }
 
  virtual Model::CreateRegistryOutcome CreateRegistry(const Model::CreateRegistryRequest& request) const;
 
  template <typename CreateRegistryRequestT = Model::CreateRegistryRequest>
  Model::CreateRegistryOutcomeCallable CreateRegistryCallable(const CreateRegistryRequestT& request) const {
    return SubmitCallable(&SchemasClient::CreateRegistry, request);
  }
 
  template <typename CreateRegistryRequestT = Model::CreateRegistryRequest>
  void CreateRegistryAsync(const CreateRegistryRequestT& request, const CreateRegistryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::CreateRegistry, request, handler, context);
  }
 
  virtual Model::CreateSchemaOutcome CreateSchema(const Model::CreateSchemaRequest& request) const;
 
  template <typename CreateSchemaRequestT = Model::CreateSchemaRequest>
  Model::CreateSchemaOutcomeCallable CreateSchemaCallable(const CreateSchemaRequestT& request) const {
    return SubmitCallable(&SchemasClient::CreateSchema, request);
  }
 
  template <typename CreateSchemaRequestT = Model::CreateSchemaRequest>
  void CreateSchemaAsync(const CreateSchemaRequestT& request, const CreateSchemaResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::CreateSchema, request, handler, context);
  }
 
  virtual Model::DeleteDiscovererOutcome DeleteDiscoverer(const Model::DeleteDiscovererRequest& request) const;
 
  template <typename DeleteDiscovererRequestT = Model::DeleteDiscovererRequest>
  Model::DeleteDiscovererOutcomeCallable DeleteDiscovererCallable(const DeleteDiscovererRequestT& request) const {
    return SubmitCallable(&SchemasClient::DeleteDiscoverer, request);
  }
 
  template <typename DeleteDiscovererRequestT = Model::DeleteDiscovererRequest>
  void DeleteDiscovererAsync(const DeleteDiscovererRequestT& request, const DeleteDiscovererResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::DeleteDiscoverer, request, handler, context);
  }
 
  virtual Model::DeleteRegistryOutcome DeleteRegistry(const Model::DeleteRegistryRequest& request) const;
 
  template <typename DeleteRegistryRequestT = Model::DeleteRegistryRequest>
  Model::DeleteRegistryOutcomeCallable DeleteRegistryCallable(const DeleteRegistryRequestT& request) const {
    return SubmitCallable(&SchemasClient::DeleteRegistry, request);
  }
 
  template <typename DeleteRegistryRequestT = Model::DeleteRegistryRequest>
  void DeleteRegistryAsync(const DeleteRegistryRequestT& request, const DeleteRegistryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::DeleteRegistry, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request = {}) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request = {}) const {
    return SubmitCallable(&SchemasClient::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DeleteResourcePolicyRequestT& request = {}) const {
    return SubmitAsync(&SchemasClient::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeleteSchemaOutcome DeleteSchema(const Model::DeleteSchemaRequest& request) const;
 
  template <typename DeleteSchemaRequestT = Model::DeleteSchemaRequest>
  Model::DeleteSchemaOutcomeCallable DeleteSchemaCallable(const DeleteSchemaRequestT& request) const {
    return SubmitCallable(&SchemasClient::DeleteSchema, request);
  }
 
  template <typename DeleteSchemaRequestT = Model::DeleteSchemaRequest>
  void DeleteSchemaAsync(const DeleteSchemaRequestT& request, const DeleteSchemaResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::DeleteSchema, request, handler, context);
  }
 
  virtual Model::DeleteSchemaVersionOutcome DeleteSchemaVersion(const Model::DeleteSchemaVersionRequest& request) const;
 
  template <typename DeleteSchemaVersionRequestT = Model::DeleteSchemaVersionRequest>
  Model::DeleteSchemaVersionOutcomeCallable DeleteSchemaVersionCallable(const DeleteSchemaVersionRequestT& request) const {
    return SubmitCallable(&SchemasClient::DeleteSchemaVersion, request);
  }
 
  template <typename DeleteSchemaVersionRequestT = Model::DeleteSchemaVersionRequest>
  void DeleteSchemaVersionAsync(const DeleteSchemaVersionRequestT& request, const DeleteSchemaVersionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::DeleteSchemaVersion, request, handler, context);
  }
 
  virtual Model::DescribeCodeBindingOutcome DescribeCodeBinding(const Model::DescribeCodeBindingRequest& request) const;
 
  template <typename DescribeCodeBindingRequestT = Model::DescribeCodeBindingRequest>
  Model::DescribeCodeBindingOutcomeCallable DescribeCodeBindingCallable(const DescribeCodeBindingRequestT& request) const {
    return SubmitCallable(&SchemasClient::DescribeCodeBinding, request);
  }
 
  template <typename DescribeCodeBindingRequestT = Model::DescribeCodeBindingRequest>
  void DescribeCodeBindingAsync(const DescribeCodeBindingRequestT& request, const DescribeCodeBindingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::DescribeCodeBinding, request, handler, context);
  }
 
  virtual Model::DescribeDiscovererOutcome DescribeDiscoverer(const Model::DescribeDiscovererRequest& request) const;
 
  template <typename DescribeDiscovererRequestT = Model::DescribeDiscovererRequest>
  Model::DescribeDiscovererOutcomeCallable DescribeDiscovererCallable(const DescribeDiscovererRequestT& request) const {
    return SubmitCallable(&SchemasClient::DescribeDiscoverer, request);
  }
 
  template <typename DescribeDiscovererRequestT = Model::DescribeDiscovererRequest>
  void DescribeDiscovererAsync(const DescribeDiscovererRequestT& request, const DescribeDiscovererResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::DescribeDiscoverer, request, handler, context);
  }
 
  virtual Model::DescribeRegistryOutcome DescribeRegistry(const Model::DescribeRegistryRequest& request) const;
 
  template <typename DescribeRegistryRequestT = Model::DescribeRegistryRequest>
  Model::DescribeRegistryOutcomeCallable DescribeRegistryCallable(const DescribeRegistryRequestT& request) const {
    return SubmitCallable(&SchemasClient::DescribeRegistry, request);
  }
 
  template <typename DescribeRegistryRequestT = Model::DescribeRegistryRequest>
  void DescribeRegistryAsync(const DescribeRegistryRequestT& request, const DescribeRegistryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::DescribeRegistry, request, handler, context);
  }
 
  virtual Model::DescribeSchemaOutcome DescribeSchema(const Model::DescribeSchemaRequest& request) const;
 
  template <typename DescribeSchemaRequestT = Model::DescribeSchemaRequest>
  Model::DescribeSchemaOutcomeCallable DescribeSchemaCallable(const DescribeSchemaRequestT& request) const {
    return SubmitCallable(&SchemasClient::DescribeSchema, request);
  }
 
  template <typename DescribeSchemaRequestT = Model::DescribeSchemaRequest>
  void DescribeSchemaAsync(const DescribeSchemaRequestT& request, const DescribeSchemaResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::DescribeSchema, request, handler, context);
  }
 
  virtual Model::ExportSchemaOutcome ExportSchema(const Model::ExportSchemaRequest& request) const;
 
  template <typename ExportSchemaRequestT = Model::ExportSchemaRequest>
  Model::ExportSchemaOutcomeCallable ExportSchemaCallable(const ExportSchemaRequestT& request) const {
    return SubmitCallable(&SchemasClient::ExportSchema, request);
  }
 
  template <typename ExportSchemaRequestT = Model::ExportSchemaRequest>
  void ExportSchemaAsync(const ExportSchemaRequestT& request, const ExportSchemaResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::ExportSchema, request, handler, context);
  }
 
  virtual Model::GetCodeBindingSourceOutcome GetCodeBindingSource(const Model::GetCodeBindingSourceRequest& request) const;
 
  template <typename GetCodeBindingSourceRequestT = Model::GetCodeBindingSourceRequest>
  Model::GetCodeBindingSourceOutcomeCallable GetCodeBindingSourceCallable(const GetCodeBindingSourceRequestT& request) const {
    return SubmitCallable(&SchemasClient::GetCodeBindingSource, request);
  }
 
  template <typename GetCodeBindingSourceRequestT = Model::GetCodeBindingSourceRequest>
  void GetCodeBindingSourceAsync(const GetCodeBindingSourceRequestT& request, const GetCodeBindingSourceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::GetCodeBindingSource, request, handler, context);
  }
 
  virtual Model::GetDiscoveredSchemaOutcome GetDiscoveredSchema(const Model::GetDiscoveredSchemaRequest& request) const;
 
  template <typename GetDiscoveredSchemaRequestT = Model::GetDiscoveredSchemaRequest>
  Model::GetDiscoveredSchemaOutcomeCallable GetDiscoveredSchemaCallable(const GetDiscoveredSchemaRequestT& request) const {
    return SubmitCallable(&SchemasClient::GetDiscoveredSchema, request);
  }
 
  template <typename GetDiscoveredSchemaRequestT = Model::GetDiscoveredSchemaRequest>
  void GetDiscoveredSchemaAsync(const GetDiscoveredSchemaRequestT& request, const GetDiscoveredSchemaResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::GetDiscoveredSchema, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request = {}) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request = {}) const {
    return SubmitCallable(&SchemasClient::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const GetResourcePolicyRequestT& request = {}) const {
    return SubmitAsync(&SchemasClient::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::ListDiscoverersOutcome ListDiscoverers(const Model::ListDiscoverersRequest& request = {}) const;
 
  template <typename ListDiscoverersRequestT = Model::ListDiscoverersRequest>
  Model::ListDiscoverersOutcomeCallable ListDiscoverersCallable(const ListDiscoverersRequestT& request = {}) const {
    return SubmitCallable(&SchemasClient::ListDiscoverers, request);
  }
 
  template <typename ListDiscoverersRequestT = Model::ListDiscoverersRequest>
  void ListDiscoverersAsync(const ListDiscoverersResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListDiscoverersRequestT& request = {}) const {
    return SubmitAsync(&SchemasClient::ListDiscoverers, request, handler, context);
  }
 
  virtual Model::ListRegistriesOutcome ListRegistries(const Model::ListRegistriesRequest& request = {}) const;
 
  template <typename ListRegistriesRequestT = Model::ListRegistriesRequest>
  Model::ListRegistriesOutcomeCallable ListRegistriesCallable(const ListRegistriesRequestT& request = {}) const {
    return SubmitCallable(&SchemasClient::ListRegistries, request);
  }
 
  template <typename ListRegistriesRequestT = Model::ListRegistriesRequest>
  void ListRegistriesAsync(const ListRegistriesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListRegistriesRequestT& request = {}) const {
    return SubmitAsync(&SchemasClient::ListRegistries, request, handler, context);
  }
 
  virtual Model::ListSchemaVersionsOutcome ListSchemaVersions(const Model::ListSchemaVersionsRequest& request) const;
 
  template <typename ListSchemaVersionsRequestT = Model::ListSchemaVersionsRequest>
  Model::ListSchemaVersionsOutcomeCallable ListSchemaVersionsCallable(const ListSchemaVersionsRequestT& request) const {
    return SubmitCallable(&SchemasClient::ListSchemaVersions, request);
  }
 
  template <typename ListSchemaVersionsRequestT = Model::ListSchemaVersionsRequest>
  void ListSchemaVersionsAsync(const ListSchemaVersionsRequestT& request, const ListSchemaVersionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::ListSchemaVersions, request, handler, context);
  }
 
  virtual Model::ListSchemasOutcome ListSchemas(const Model::ListSchemasRequest& request) const;
 
  template <typename ListSchemasRequestT = Model::ListSchemasRequest>
  Model::ListSchemasOutcomeCallable ListSchemasCallable(const ListSchemasRequestT& request) const {
    return SubmitCallable(&SchemasClient::ListSchemas, request);
  }
 
  template <typename ListSchemasRequestT = Model::ListSchemasRequest>
  void ListSchemasAsync(const ListSchemasRequestT& request, const ListSchemasResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::ListSchemas, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&SchemasClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutCodeBindingOutcome PutCodeBinding(const Model::PutCodeBindingRequest& request) const;
 
  template <typename PutCodeBindingRequestT = Model::PutCodeBindingRequest>
  Model::PutCodeBindingOutcomeCallable PutCodeBindingCallable(const PutCodeBindingRequestT& request) const {
    return SubmitCallable(&SchemasClient::PutCodeBinding, request);
  }
 
  template <typename PutCodeBindingRequestT = Model::PutCodeBindingRequest>
  void PutCodeBindingAsync(const PutCodeBindingRequestT& request, const PutCodeBindingResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::PutCodeBinding, request, handler, context);
  }
 
  virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&SchemasClient::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::PutResourcePolicy, request, handler, context);
  }
 
  virtual Model::SearchSchemasOutcome SearchSchemas(const Model::SearchSchemasRequest& request) const;
 
  template <typename SearchSchemasRequestT = Model::SearchSchemasRequest>
  Model::SearchSchemasOutcomeCallable SearchSchemasCallable(const SearchSchemasRequestT& request) const {
    return SubmitCallable(&SchemasClient::SearchSchemas, request);
  }
 
  template <typename SearchSchemasRequestT = Model::SearchSchemasRequest>
  void SearchSchemasAsync(const SearchSchemasRequestT& request, const SearchSchemasResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::SearchSchemas, request, handler, context);
  }
 
  virtual Model::StartDiscovererOutcome StartDiscoverer(const Model::StartDiscovererRequest& request) const;
 
  template <typename StartDiscovererRequestT = Model::StartDiscovererRequest>
  Model::StartDiscovererOutcomeCallable StartDiscovererCallable(const StartDiscovererRequestT& request) const {
    return SubmitCallable(&SchemasClient::StartDiscoverer, request);
  }
 
  template <typename StartDiscovererRequestT = Model::StartDiscovererRequest>
  void StartDiscovererAsync(const StartDiscovererRequestT& request, const StartDiscovererResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::StartDiscoverer, request, handler, context);
  }
 
  virtual Model::StopDiscovererOutcome StopDiscoverer(const Model::StopDiscovererRequest& request) const;
 
  template <typename StopDiscovererRequestT = Model::StopDiscovererRequest>
  Model::StopDiscovererOutcomeCallable StopDiscovererCallable(const StopDiscovererRequestT& request) const {
    return SubmitCallable(&SchemasClient::StopDiscoverer, request);
  }
 
  template <typename StopDiscovererRequestT = Model::StopDiscovererRequest>
  void StopDiscovererAsync(const StopDiscovererRequestT& request, const StopDiscovererResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::StopDiscoverer, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&SchemasClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&SchemasClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateDiscovererOutcome UpdateDiscoverer(const Model::UpdateDiscovererRequest& request) const;
 
  template <typename UpdateDiscovererRequestT = Model::UpdateDiscovererRequest>
  Model::UpdateDiscovererOutcomeCallable UpdateDiscovererCallable(const UpdateDiscovererRequestT& request) const {
    return SubmitCallable(&SchemasClient::UpdateDiscoverer, request);
  }
 
  template <typename UpdateDiscovererRequestT = Model::UpdateDiscovererRequest>
  void UpdateDiscovererAsync(const UpdateDiscovererRequestT& request, const UpdateDiscovererResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::UpdateDiscoverer, request, handler, context);
  }
 
  virtual Model::UpdateRegistryOutcome UpdateRegistry(const Model::UpdateRegistryRequest& request) const;
 
  template <typename UpdateRegistryRequestT = Model::UpdateRegistryRequest>
  Model::UpdateRegistryOutcomeCallable UpdateRegistryCallable(const UpdateRegistryRequestT& request) const {
    return SubmitCallable(&SchemasClient::UpdateRegistry, request);
  }
 
  template <typename UpdateRegistryRequestT = Model::UpdateRegistryRequest>
  void UpdateRegistryAsync(const UpdateRegistryRequestT& request, const UpdateRegistryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::UpdateRegistry, request, handler, context);
  }
 
  virtual Model::UpdateSchemaOutcome UpdateSchema(const Model::UpdateSchemaRequest& request) const;
 
  template <typename UpdateSchemaRequestT = Model::UpdateSchemaRequest>
  Model::UpdateSchemaOutcomeCallable UpdateSchemaCallable(const UpdateSchemaRequestT& request) const {
    return SubmitCallable(&SchemasClient::UpdateSchema, request);
  }
 
  template <typename UpdateSchemaRequestT = Model::UpdateSchemaRequest>
  void UpdateSchemaAsync(const UpdateSchemaRequestT& request, const UpdateSchemaResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchemasClient::UpdateSchema, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SchemasEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SchemasClient>;
  void init(const SchemasClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SchemasError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  SchemasClientConfiguration m_clientConfiguration;
  std::shared_ptr<SchemasEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Schemas
}  // namespace Aws