AmplifyUIBuilderClient.h

 
#pragma once
#include <aws/amplifyuibuilder/AmplifyUIBuilder_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/amplifyuibuilder/AmplifyUIBuilderServiceClientModel.h>
 
namespace Aws
{
namespace AmplifyUIBuilder
{
  class AWS_AMPLIFYUIBUILDER_API AmplifyUIBuilderClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AmplifyUIBuilderClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef AmplifyUIBuilderClientConfiguration ClientConfigurationType;
      typedef AmplifyUIBuilderEndpointProvider EndpointProviderType;
 
        AmplifyUIBuilderClient(const Aws::AmplifyUIBuilder::AmplifyUIBuilderClientConfiguration& clientConfiguration = Aws::AmplifyUIBuilder::AmplifyUIBuilderClientConfiguration(),
                               std::shared_ptr<AmplifyUIBuilderEndpointProviderBase> endpointProvider = nullptr);
 
        AmplifyUIBuilderClient(const Aws::Auth::AWSCredentials& credentials,
                               std::shared_ptr<AmplifyUIBuilderEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::AmplifyUIBuilder::AmplifyUIBuilderClientConfiguration& clientConfiguration = Aws::AmplifyUIBuilder::AmplifyUIBuilderClientConfiguration());
 
        AmplifyUIBuilderClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               std::shared_ptr<AmplifyUIBuilderEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::AmplifyUIBuilder::AmplifyUIBuilderClientConfiguration& clientConfiguration = Aws::AmplifyUIBuilder::AmplifyUIBuilderClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        AmplifyUIBuilderClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AmplifyUIBuilderClient(const Aws::Auth::AWSCredentials& credentials,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AmplifyUIBuilderClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~AmplifyUIBuilderClient();
 
        virtual Model::CreateComponentOutcome CreateComponent(const Model::CreateComponentRequest& request) const;
 
        template<typename CreateComponentRequestT = Model::CreateComponentRequest>
        Model::CreateComponentOutcomeCallable CreateComponentCallable(const CreateComponentRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::CreateComponent, request);
        }
 
        template<typename CreateComponentRequestT = Model::CreateComponentRequest>
        void CreateComponentAsync(const CreateComponentRequestT& request, const CreateComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::CreateComponent, request, handler, context);
        }
 
        virtual Model::CreateFormOutcome CreateForm(const Model::CreateFormRequest& request) const;
 
        template<typename CreateFormRequestT = Model::CreateFormRequest>
        Model::CreateFormOutcomeCallable CreateFormCallable(const CreateFormRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::CreateForm, request);
        }
 
        template<typename CreateFormRequestT = Model::CreateFormRequest>
        void CreateFormAsync(const CreateFormRequestT& request, const CreateFormResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::CreateForm, request, handler, context);
        }
 
        virtual Model::CreateThemeOutcome CreateTheme(const Model::CreateThemeRequest& request) const;
 
        template<typename CreateThemeRequestT = Model::CreateThemeRequest>
        Model::CreateThemeOutcomeCallable CreateThemeCallable(const CreateThemeRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::CreateTheme, request);
        }
 
        template<typename CreateThemeRequestT = Model::CreateThemeRequest>
        void CreateThemeAsync(const CreateThemeRequestT& request, const CreateThemeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::CreateTheme, request, handler, context);
        }
 
        virtual Model::DeleteComponentOutcome DeleteComponent(const Model::DeleteComponentRequest& request) const;
 
        template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
        Model::DeleteComponentOutcomeCallable DeleteComponentCallable(const DeleteComponentRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::DeleteComponent, request);
        }
 
        template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
        void DeleteComponentAsync(const DeleteComponentRequestT& request, const DeleteComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::DeleteComponent, request, handler, context);
        }
 
        virtual Model::DeleteFormOutcome DeleteForm(const Model::DeleteFormRequest& request) const;
 
        template<typename DeleteFormRequestT = Model::DeleteFormRequest>
        Model::DeleteFormOutcomeCallable DeleteFormCallable(const DeleteFormRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::DeleteForm, request);
        }
 
        template<typename DeleteFormRequestT = Model::DeleteFormRequest>
        void DeleteFormAsync(const DeleteFormRequestT& request, const DeleteFormResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::DeleteForm, request, handler, context);
        }
 
        virtual Model::DeleteThemeOutcome DeleteTheme(const Model::DeleteThemeRequest& request) const;
 
        template<typename DeleteThemeRequestT = Model::DeleteThemeRequest>
        Model::DeleteThemeOutcomeCallable DeleteThemeCallable(const DeleteThemeRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::DeleteTheme, request);
        }
 
        template<typename DeleteThemeRequestT = Model::DeleteThemeRequest>
        void DeleteThemeAsync(const DeleteThemeRequestT& request, const DeleteThemeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::DeleteTheme, request, handler, context);
        }
 
        virtual Model::ExchangeCodeForTokenOutcome ExchangeCodeForToken(const Model::ExchangeCodeForTokenRequest& request) const;
 
        template<typename ExchangeCodeForTokenRequestT = Model::ExchangeCodeForTokenRequest>
        Model::ExchangeCodeForTokenOutcomeCallable ExchangeCodeForTokenCallable(const ExchangeCodeForTokenRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::ExchangeCodeForToken, request);
        }
 
        template<typename ExchangeCodeForTokenRequestT = Model::ExchangeCodeForTokenRequest>
        void ExchangeCodeForTokenAsync(const ExchangeCodeForTokenRequestT& request, const ExchangeCodeForTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::ExchangeCodeForToken, request, handler, context);
        }
 
        virtual Model::ExportComponentsOutcome ExportComponents(const Model::ExportComponentsRequest& request) const;
 
        template<typename ExportComponentsRequestT = Model::ExportComponentsRequest>
        Model::ExportComponentsOutcomeCallable ExportComponentsCallable(const ExportComponentsRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::ExportComponents, request);
        }
 
        template<typename ExportComponentsRequestT = Model::ExportComponentsRequest>
        void ExportComponentsAsync(const ExportComponentsRequestT& request, const ExportComponentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::ExportComponents, request, handler, context);
        }
 
        virtual Model::ExportFormsOutcome ExportForms(const Model::ExportFormsRequest& request) const;
 
        template<typename ExportFormsRequestT = Model::ExportFormsRequest>
        Model::ExportFormsOutcomeCallable ExportFormsCallable(const ExportFormsRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::ExportForms, request);
        }
 
        template<typename ExportFormsRequestT = Model::ExportFormsRequest>
        void ExportFormsAsync(const ExportFormsRequestT& request, const ExportFormsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::ExportForms, request, handler, context);
        }
 
        virtual Model::ExportThemesOutcome ExportThemes(const Model::ExportThemesRequest& request) const;
 
        template<typename ExportThemesRequestT = Model::ExportThemesRequest>
        Model::ExportThemesOutcomeCallable ExportThemesCallable(const ExportThemesRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::ExportThemes, request);
        }
 
        template<typename ExportThemesRequestT = Model::ExportThemesRequest>
        void ExportThemesAsync(const ExportThemesRequestT& request, const ExportThemesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::ExportThemes, request, handler, context);
        }
 
        virtual Model::GetCodegenJobOutcome GetCodegenJob(const Model::GetCodegenJobRequest& request) const;
 
        template<typename GetCodegenJobRequestT = Model::GetCodegenJobRequest>
        Model::GetCodegenJobOutcomeCallable GetCodegenJobCallable(const GetCodegenJobRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::GetCodegenJob, request);
        }
 
        template<typename GetCodegenJobRequestT = Model::GetCodegenJobRequest>
        void GetCodegenJobAsync(const GetCodegenJobRequestT& request, const GetCodegenJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::GetCodegenJob, request, handler, context);
        }
 
        virtual Model::GetComponentOutcome GetComponent(const Model::GetComponentRequest& request) const;
 
        template<typename GetComponentRequestT = Model::GetComponentRequest>
        Model::GetComponentOutcomeCallable GetComponentCallable(const GetComponentRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::GetComponent, request);
        }
 
        template<typename GetComponentRequestT = Model::GetComponentRequest>
        void GetComponentAsync(const GetComponentRequestT& request, const GetComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::GetComponent, request, handler, context);
        }
 
        virtual Model::GetFormOutcome GetForm(const Model::GetFormRequest& request) const;
 
        template<typename GetFormRequestT = Model::GetFormRequest>
        Model::GetFormOutcomeCallable GetFormCallable(const GetFormRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::GetForm, request);
        }
 
        template<typename GetFormRequestT = Model::GetFormRequest>
        void GetFormAsync(const GetFormRequestT& request, const GetFormResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::GetForm, request, handler, context);
        }
 
        virtual Model::GetMetadataOutcome GetMetadata(const Model::GetMetadataRequest& request) const;
 
        template<typename GetMetadataRequestT = Model::GetMetadataRequest>
        Model::GetMetadataOutcomeCallable GetMetadataCallable(const GetMetadataRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::GetMetadata, request);
        }
 
        template<typename GetMetadataRequestT = Model::GetMetadataRequest>
        void GetMetadataAsync(const GetMetadataRequestT& request, const GetMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::GetMetadata, request, handler, context);
        }
 
        virtual Model::GetThemeOutcome GetTheme(const Model::GetThemeRequest& request) const;
 
        template<typename GetThemeRequestT = Model::GetThemeRequest>
        Model::GetThemeOutcomeCallable GetThemeCallable(const GetThemeRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::GetTheme, request);
        }
 
        template<typename GetThemeRequestT = Model::GetThemeRequest>
        void GetThemeAsync(const GetThemeRequestT& request, const GetThemeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::GetTheme, request, handler, context);
        }
 
        virtual Model::ListCodegenJobsOutcome ListCodegenJobs(const Model::ListCodegenJobsRequest& request) const;
 
        template<typename ListCodegenJobsRequestT = Model::ListCodegenJobsRequest>
        Model::ListCodegenJobsOutcomeCallable ListCodegenJobsCallable(const ListCodegenJobsRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::ListCodegenJobs, request);
        }
 
        template<typename ListCodegenJobsRequestT = Model::ListCodegenJobsRequest>
        void ListCodegenJobsAsync(const ListCodegenJobsRequestT& request, const ListCodegenJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::ListCodegenJobs, request, handler, context);
        }
 
        virtual Model::ListComponentsOutcome ListComponents(const Model::ListComponentsRequest& request) const;
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        Model::ListComponentsOutcomeCallable ListComponentsCallable(const ListComponentsRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::ListComponents, request);
        }
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        void ListComponentsAsync(const ListComponentsRequestT& request, const ListComponentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::ListComponents, request, handler, context);
        }
 
        virtual Model::ListFormsOutcome ListForms(const Model::ListFormsRequest& request) const;
 
        template<typename ListFormsRequestT = Model::ListFormsRequest>
        Model::ListFormsOutcomeCallable ListFormsCallable(const ListFormsRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::ListForms, request);
        }
 
        template<typename ListFormsRequestT = Model::ListFormsRequest>
        void ListFormsAsync(const ListFormsRequestT& request, const ListFormsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::ListForms, 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(&AmplifyUIBuilderClient::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(&AmplifyUIBuilderClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListThemesOutcome ListThemes(const Model::ListThemesRequest& request) const;
 
        template<typename ListThemesRequestT = Model::ListThemesRequest>
        Model::ListThemesOutcomeCallable ListThemesCallable(const ListThemesRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::ListThemes, request);
        }
 
        template<typename ListThemesRequestT = Model::ListThemesRequest>
        void ListThemesAsync(const ListThemesRequestT& request, const ListThemesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::ListThemes, request, handler, context);
        }
 
        virtual Model::PutMetadataFlagOutcome PutMetadataFlag(const Model::PutMetadataFlagRequest& request) const;
 
        template<typename PutMetadataFlagRequestT = Model::PutMetadataFlagRequest>
        Model::PutMetadataFlagOutcomeCallable PutMetadataFlagCallable(const PutMetadataFlagRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::PutMetadataFlag, request);
        }
 
        template<typename PutMetadataFlagRequestT = Model::PutMetadataFlagRequest>
        void PutMetadataFlagAsync(const PutMetadataFlagRequestT& request, const PutMetadataFlagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::PutMetadataFlag, request, handler, context);
        }
 
        virtual Model::RefreshTokenOutcome RefreshToken(const Model::RefreshTokenRequest& request) const;
 
        template<typename RefreshTokenRequestT = Model::RefreshTokenRequest>
        Model::RefreshTokenOutcomeCallable RefreshTokenCallable(const RefreshTokenRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::RefreshToken, request);
        }
 
        template<typename RefreshTokenRequestT = Model::RefreshTokenRequest>
        void RefreshTokenAsync(const RefreshTokenRequestT& request, const RefreshTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::RefreshToken, request, handler, context);
        }
 
        virtual Model::StartCodegenJobOutcome StartCodegenJob(const Model::StartCodegenJobRequest& request) const;
 
        template<typename StartCodegenJobRequestT = Model::StartCodegenJobRequest>
        Model::StartCodegenJobOutcomeCallable StartCodegenJobCallable(const StartCodegenJobRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::StartCodegenJob, request);
        }
 
        template<typename StartCodegenJobRequestT = Model::StartCodegenJobRequest>
        void StartCodegenJobAsync(const StartCodegenJobRequestT& request, const StartCodegenJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::StartCodegenJob, 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(&AmplifyUIBuilderClient::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(&AmplifyUIBuilderClient::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(&AmplifyUIBuilderClient::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(&AmplifyUIBuilderClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateComponentOutcome UpdateComponent(const Model::UpdateComponentRequest& request) const;
 
        template<typename UpdateComponentRequestT = Model::UpdateComponentRequest>
        Model::UpdateComponentOutcomeCallable UpdateComponentCallable(const UpdateComponentRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::UpdateComponent, request);
        }
 
        template<typename UpdateComponentRequestT = Model::UpdateComponentRequest>
        void UpdateComponentAsync(const UpdateComponentRequestT& request, const UpdateComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::UpdateComponent, request, handler, context);
        }
 
        virtual Model::UpdateFormOutcome UpdateForm(const Model::UpdateFormRequest& request) const;
 
        template<typename UpdateFormRequestT = Model::UpdateFormRequest>
        Model::UpdateFormOutcomeCallable UpdateFormCallable(const UpdateFormRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::UpdateForm, request);
        }
 
        template<typename UpdateFormRequestT = Model::UpdateFormRequest>
        void UpdateFormAsync(const UpdateFormRequestT& request, const UpdateFormResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::UpdateForm, request, handler, context);
        }
 
        virtual Model::UpdateThemeOutcome UpdateTheme(const Model::UpdateThemeRequest& request) const;
 
        template<typename UpdateThemeRequestT = Model::UpdateThemeRequest>
        Model::UpdateThemeOutcomeCallable UpdateThemeCallable(const UpdateThemeRequestT& request) const
        {
            return SubmitCallable(&AmplifyUIBuilderClient::UpdateTheme, request);
        }
 
        template<typename UpdateThemeRequestT = Model::UpdateThemeRequest>
        void UpdateThemeAsync(const UpdateThemeRequestT& request, const UpdateThemeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyUIBuilderClient::UpdateTheme, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AmplifyUIBuilderEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AmplifyUIBuilderClient>;
      void init(const AmplifyUIBuilderClientConfiguration& clientConfiguration);
 
      AmplifyUIBuilderClientConfiguration m_clientConfiguration;
      std::shared_ptr<AmplifyUIBuilderEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AmplifyUIBuilder
} // namespace Aws