SchemasClient.h

 
#pragma once
#include <aws/schemas/Schemas_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/schemas/SchemasServiceClientModel.h>
 
namespace Aws
{
namespace Schemas
{
  class AWS_SCHEMAS_API SchemasClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SchemasEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SchemasClient>;
      void init(const SchemasClientConfiguration& clientConfiguration);
 
      SchemasClientConfiguration m_clientConfiguration;
      std::shared_ptr<SchemasEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Schemas
} // namespace Aws