CloudFormationClient.h

 
#pragma once
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/cloudformation/CloudFormationServiceClientModel.h>
 
namespace Aws
{
namespace CloudFormation
{
  class AWS_CLOUDFORMATION_API CloudFormationClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<CloudFormationClient>
  {
    public:
      typedef Aws::Client::AWSXMLClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CloudFormationClientConfiguration ClientConfigurationType;
      typedef CloudFormationEndpointProvider EndpointProviderType;
 
        CloudFormationClient(const Aws::CloudFormation::CloudFormationClientConfiguration& clientConfiguration = Aws::CloudFormation::CloudFormationClientConfiguration(),
                             std::shared_ptr<CloudFormationEndpointProviderBase> endpointProvider = nullptr);
 
        CloudFormationClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<CloudFormationEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::CloudFormation::CloudFormationClientConfiguration& clientConfiguration = Aws::CloudFormation::CloudFormationClientConfiguration());
 
        CloudFormationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<CloudFormationEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::CloudFormation::CloudFormationClientConfiguration& clientConfiguration = Aws::CloudFormation::CloudFormationClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CloudFormationClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CloudFormationClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CloudFormationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CloudFormationClient();
 
 
        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
 
        virtual Model::ActivateOrganizationsAccessOutcome ActivateOrganizationsAccess(const Model::ActivateOrganizationsAccessRequest& request = {}) const;
 
        template<typename ActivateOrganizationsAccessRequestT = Model::ActivateOrganizationsAccessRequest>
        Model::ActivateOrganizationsAccessOutcomeCallable ActivateOrganizationsAccessCallable(const ActivateOrganizationsAccessRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ActivateOrganizationsAccess, request);
        }
 
        template<typename ActivateOrganizationsAccessRequestT = Model::ActivateOrganizationsAccessRequest>
        void ActivateOrganizationsAccessAsync(const ActivateOrganizationsAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ActivateOrganizationsAccessRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ActivateOrganizationsAccess, request, handler, context);
        }
 
        virtual Model::ActivateTypeOutcome ActivateType(const Model::ActivateTypeRequest& request = {}) const;
 
        template<typename ActivateTypeRequestT = Model::ActivateTypeRequest>
        Model::ActivateTypeOutcomeCallable ActivateTypeCallable(const ActivateTypeRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ActivateType, request);
        }
 
        template<typename ActivateTypeRequestT = Model::ActivateTypeRequest>
        void ActivateTypeAsync(const ActivateTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ActivateTypeRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ActivateType, request, handler, context);
        }
 
        virtual Model::BatchDescribeTypeConfigurationsOutcome BatchDescribeTypeConfigurations(const Model::BatchDescribeTypeConfigurationsRequest& request) const;
 
        template<typename BatchDescribeTypeConfigurationsRequestT = Model::BatchDescribeTypeConfigurationsRequest>
        Model::BatchDescribeTypeConfigurationsOutcomeCallable BatchDescribeTypeConfigurationsCallable(const BatchDescribeTypeConfigurationsRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::BatchDescribeTypeConfigurations, request);
        }
 
        template<typename BatchDescribeTypeConfigurationsRequestT = Model::BatchDescribeTypeConfigurationsRequest>
        void BatchDescribeTypeConfigurationsAsync(const BatchDescribeTypeConfigurationsRequestT& request, const BatchDescribeTypeConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::BatchDescribeTypeConfigurations, request, handler, context);
        }
 
        virtual Model::CancelUpdateStackOutcome CancelUpdateStack(const Model::CancelUpdateStackRequest& request) const;
 
        template<typename CancelUpdateStackRequestT = Model::CancelUpdateStackRequest>
        Model::CancelUpdateStackOutcomeCallable CancelUpdateStackCallable(const CancelUpdateStackRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::CancelUpdateStack, request);
        }
 
        template<typename CancelUpdateStackRequestT = Model::CancelUpdateStackRequest>
        void CancelUpdateStackAsync(const CancelUpdateStackRequestT& request, const CancelUpdateStackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::CancelUpdateStack, request, handler, context);
        }
 
        virtual Model::ContinueUpdateRollbackOutcome ContinueUpdateRollback(const Model::ContinueUpdateRollbackRequest& request) const;
 
        template<typename ContinueUpdateRollbackRequestT = Model::ContinueUpdateRollbackRequest>
        Model::ContinueUpdateRollbackOutcomeCallable ContinueUpdateRollbackCallable(const ContinueUpdateRollbackRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ContinueUpdateRollback, request);
        }
 
        template<typename ContinueUpdateRollbackRequestT = Model::ContinueUpdateRollbackRequest>
        void ContinueUpdateRollbackAsync(const ContinueUpdateRollbackRequestT& request, const ContinueUpdateRollbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ContinueUpdateRollback, request, handler, context);
        }
 
        virtual Model::CreateChangeSetOutcome CreateChangeSet(const Model::CreateChangeSetRequest& request) const;
 
        template<typename CreateChangeSetRequestT = Model::CreateChangeSetRequest>
        Model::CreateChangeSetOutcomeCallable CreateChangeSetCallable(const CreateChangeSetRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::CreateChangeSet, request);
        }
 
        template<typename CreateChangeSetRequestT = Model::CreateChangeSetRequest>
        void CreateChangeSetAsync(const CreateChangeSetRequestT& request, const CreateChangeSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::CreateChangeSet, request, handler, context);
        }
 
        virtual Model::CreateGeneratedTemplateOutcome CreateGeneratedTemplate(const Model::CreateGeneratedTemplateRequest& request) const;
 
        template<typename CreateGeneratedTemplateRequestT = Model::CreateGeneratedTemplateRequest>
        Model::CreateGeneratedTemplateOutcomeCallable CreateGeneratedTemplateCallable(const CreateGeneratedTemplateRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::CreateGeneratedTemplate, request);
        }
 
        template<typename CreateGeneratedTemplateRequestT = Model::CreateGeneratedTemplateRequest>
        void CreateGeneratedTemplateAsync(const CreateGeneratedTemplateRequestT& request, const CreateGeneratedTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::CreateGeneratedTemplate, request, handler, context);
        }
 
        virtual Model::CreateStackOutcome CreateStack(const Model::CreateStackRequest& request) const;
 
        template<typename CreateStackRequestT = Model::CreateStackRequest>
        Model::CreateStackOutcomeCallable CreateStackCallable(const CreateStackRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::CreateStack, request);
        }
 
        template<typename CreateStackRequestT = Model::CreateStackRequest>
        void CreateStackAsync(const CreateStackRequestT& request, const CreateStackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::CreateStack, request, handler, context);
        }
 
        virtual Model::CreateStackInstancesOutcome CreateStackInstances(const Model::CreateStackInstancesRequest& request) const;
 
        template<typename CreateStackInstancesRequestT = Model::CreateStackInstancesRequest>
        Model::CreateStackInstancesOutcomeCallable CreateStackInstancesCallable(const CreateStackInstancesRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::CreateStackInstances, request);
        }
 
        template<typename CreateStackInstancesRequestT = Model::CreateStackInstancesRequest>
        void CreateStackInstancesAsync(const CreateStackInstancesRequestT& request, const CreateStackInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::CreateStackInstances, request, handler, context);
        }
 
        virtual Model::CreateStackSetOutcome CreateStackSet(const Model::CreateStackSetRequest& request) const;
 
        template<typename CreateStackSetRequestT = Model::CreateStackSetRequest>
        Model::CreateStackSetOutcomeCallable CreateStackSetCallable(const CreateStackSetRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::CreateStackSet, request);
        }
 
        template<typename CreateStackSetRequestT = Model::CreateStackSetRequest>
        void CreateStackSetAsync(const CreateStackSetRequestT& request, const CreateStackSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::CreateStackSet, request, handler, context);
        }
 
        virtual Model::DeactivateOrganizationsAccessOutcome DeactivateOrganizationsAccess(const Model::DeactivateOrganizationsAccessRequest& request = {}) const;
 
        template<typename DeactivateOrganizationsAccessRequestT = Model::DeactivateOrganizationsAccessRequest>
        Model::DeactivateOrganizationsAccessOutcomeCallable DeactivateOrganizationsAccessCallable(const DeactivateOrganizationsAccessRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::DeactivateOrganizationsAccess, request);
        }
 
        template<typename DeactivateOrganizationsAccessRequestT = Model::DeactivateOrganizationsAccessRequest>
        void DeactivateOrganizationsAccessAsync(const DeactivateOrganizationsAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeactivateOrganizationsAccessRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::DeactivateOrganizationsAccess, request, handler, context);
        }
 
        virtual Model::DeactivateTypeOutcome DeactivateType(const Model::DeactivateTypeRequest& request = {}) const;
 
        template<typename DeactivateTypeRequestT = Model::DeactivateTypeRequest>
        Model::DeactivateTypeOutcomeCallable DeactivateTypeCallable(const DeactivateTypeRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::DeactivateType, request);
        }
 
        template<typename DeactivateTypeRequestT = Model::DeactivateTypeRequest>
        void DeactivateTypeAsync(const DeactivateTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeactivateTypeRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::DeactivateType, request, handler, context);
        }
 
        virtual Model::DeleteChangeSetOutcome DeleteChangeSet(const Model::DeleteChangeSetRequest& request) const;
 
        template<typename DeleteChangeSetRequestT = Model::DeleteChangeSetRequest>
        Model::DeleteChangeSetOutcomeCallable DeleteChangeSetCallable(const DeleteChangeSetRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DeleteChangeSet, request);
        }
 
        template<typename DeleteChangeSetRequestT = Model::DeleteChangeSetRequest>
        void DeleteChangeSetAsync(const DeleteChangeSetRequestT& request, const DeleteChangeSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DeleteChangeSet, request, handler, context);
        }
 
        virtual Model::DeleteGeneratedTemplateOutcome DeleteGeneratedTemplate(const Model::DeleteGeneratedTemplateRequest& request) const;
 
        template<typename DeleteGeneratedTemplateRequestT = Model::DeleteGeneratedTemplateRequest>
        Model::DeleteGeneratedTemplateOutcomeCallable DeleteGeneratedTemplateCallable(const DeleteGeneratedTemplateRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DeleteGeneratedTemplate, request);
        }
 
        template<typename DeleteGeneratedTemplateRequestT = Model::DeleteGeneratedTemplateRequest>
        void DeleteGeneratedTemplateAsync(const DeleteGeneratedTemplateRequestT& request, const DeleteGeneratedTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DeleteGeneratedTemplate, request, handler, context);
        }
 
        virtual Model::DeleteStackOutcome DeleteStack(const Model::DeleteStackRequest& request) const;
 
        template<typename DeleteStackRequestT = Model::DeleteStackRequest>
        Model::DeleteStackOutcomeCallable DeleteStackCallable(const DeleteStackRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DeleteStack, request);
        }
 
        template<typename DeleteStackRequestT = Model::DeleteStackRequest>
        void DeleteStackAsync(const DeleteStackRequestT& request, const DeleteStackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DeleteStack, request, handler, context);
        }
 
        virtual Model::DeleteStackInstancesOutcome DeleteStackInstances(const Model::DeleteStackInstancesRequest& request) const;
 
        template<typename DeleteStackInstancesRequestT = Model::DeleteStackInstancesRequest>
        Model::DeleteStackInstancesOutcomeCallable DeleteStackInstancesCallable(const DeleteStackInstancesRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DeleteStackInstances, request);
        }
 
        template<typename DeleteStackInstancesRequestT = Model::DeleteStackInstancesRequest>
        void DeleteStackInstancesAsync(const DeleteStackInstancesRequestT& request, const DeleteStackInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DeleteStackInstances, request, handler, context);
        }
 
        virtual Model::DeleteStackSetOutcome DeleteStackSet(const Model::DeleteStackSetRequest& request) const;
 
        template<typename DeleteStackSetRequestT = Model::DeleteStackSetRequest>
        Model::DeleteStackSetOutcomeCallable DeleteStackSetCallable(const DeleteStackSetRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DeleteStackSet, request);
        }
 
        template<typename DeleteStackSetRequestT = Model::DeleteStackSetRequest>
        void DeleteStackSetAsync(const DeleteStackSetRequestT& request, const DeleteStackSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DeleteStackSet, request, handler, context);
        }
 
        virtual Model::DeregisterTypeOutcome DeregisterType(const Model::DeregisterTypeRequest& request = {}) const;
 
        template<typename DeregisterTypeRequestT = Model::DeregisterTypeRequest>
        Model::DeregisterTypeOutcomeCallable DeregisterTypeCallable(const DeregisterTypeRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::DeregisterType, request);
        }
 
        template<typename DeregisterTypeRequestT = Model::DeregisterTypeRequest>
        void DeregisterTypeAsync(const DeregisterTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeregisterTypeRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::DeregisterType, request, handler, context);
        }
 
        virtual Model::DescribeAccountLimitsOutcome DescribeAccountLimits(const Model::DescribeAccountLimitsRequest& request = {}) const;
 
        template<typename DescribeAccountLimitsRequestT = Model::DescribeAccountLimitsRequest>
        Model::DescribeAccountLimitsOutcomeCallable DescribeAccountLimitsCallable(const DescribeAccountLimitsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeAccountLimits, request);
        }
 
        template<typename DescribeAccountLimitsRequestT = Model::DescribeAccountLimitsRequest>
        void DescribeAccountLimitsAsync(const DescribeAccountLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAccountLimitsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeAccountLimits, request, handler, context);
        }
 
        virtual Model::DescribeChangeSetOutcome DescribeChangeSet(const Model::DescribeChangeSetRequest& request) const;
 
        template<typename DescribeChangeSetRequestT = Model::DescribeChangeSetRequest>
        Model::DescribeChangeSetOutcomeCallable DescribeChangeSetCallable(const DescribeChangeSetRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeChangeSet, request);
        }
 
        template<typename DescribeChangeSetRequestT = Model::DescribeChangeSetRequest>
        void DescribeChangeSetAsync(const DescribeChangeSetRequestT& request, const DescribeChangeSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeChangeSet, request, handler, context);
        }
 
        virtual Model::DescribeChangeSetHooksOutcome DescribeChangeSetHooks(const Model::DescribeChangeSetHooksRequest& request) const;
 
        template<typename DescribeChangeSetHooksRequestT = Model::DescribeChangeSetHooksRequest>
        Model::DescribeChangeSetHooksOutcomeCallable DescribeChangeSetHooksCallable(const DescribeChangeSetHooksRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeChangeSetHooks, request);
        }
 
        template<typename DescribeChangeSetHooksRequestT = Model::DescribeChangeSetHooksRequest>
        void DescribeChangeSetHooksAsync(const DescribeChangeSetHooksRequestT& request, const DescribeChangeSetHooksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeChangeSetHooks, request, handler, context);
        }
 
        virtual Model::DescribeGeneratedTemplateOutcome DescribeGeneratedTemplate(const Model::DescribeGeneratedTemplateRequest& request) const;
 
        template<typename DescribeGeneratedTemplateRequestT = Model::DescribeGeneratedTemplateRequest>
        Model::DescribeGeneratedTemplateOutcomeCallable DescribeGeneratedTemplateCallable(const DescribeGeneratedTemplateRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeGeneratedTemplate, request);
        }
 
        template<typename DescribeGeneratedTemplateRequestT = Model::DescribeGeneratedTemplateRequest>
        void DescribeGeneratedTemplateAsync(const DescribeGeneratedTemplateRequestT& request, const DescribeGeneratedTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeGeneratedTemplate, request, handler, context);
        }
 
        virtual Model::DescribeOrganizationsAccessOutcome DescribeOrganizationsAccess(const Model::DescribeOrganizationsAccessRequest& request = {}) const;
 
        template<typename DescribeOrganizationsAccessRequestT = Model::DescribeOrganizationsAccessRequest>
        Model::DescribeOrganizationsAccessOutcomeCallable DescribeOrganizationsAccessCallable(const DescribeOrganizationsAccessRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeOrganizationsAccess, request);
        }
 
        template<typename DescribeOrganizationsAccessRequestT = Model::DescribeOrganizationsAccessRequest>
        void DescribeOrganizationsAccessAsync(const DescribeOrganizationsAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeOrganizationsAccessRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeOrganizationsAccess, request, handler, context);
        }
 
        virtual Model::DescribePublisherOutcome DescribePublisher(const Model::DescribePublisherRequest& request = {}) const;
 
        template<typename DescribePublisherRequestT = Model::DescribePublisherRequest>
        Model::DescribePublisherOutcomeCallable DescribePublisherCallable(const DescribePublisherRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::DescribePublisher, request);
        }
 
        template<typename DescribePublisherRequestT = Model::DescribePublisherRequest>
        void DescribePublisherAsync(const DescribePublisherResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribePublisherRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::DescribePublisher, request, handler, context);
        }
 
        virtual Model::DescribeResourceScanOutcome DescribeResourceScan(const Model::DescribeResourceScanRequest& request) const;
 
        template<typename DescribeResourceScanRequestT = Model::DescribeResourceScanRequest>
        Model::DescribeResourceScanOutcomeCallable DescribeResourceScanCallable(const DescribeResourceScanRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeResourceScan, request);
        }
 
        template<typename DescribeResourceScanRequestT = Model::DescribeResourceScanRequest>
        void DescribeResourceScanAsync(const DescribeResourceScanRequestT& request, const DescribeResourceScanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeResourceScan, request, handler, context);
        }
 
        virtual Model::DescribeStackDriftDetectionStatusOutcome DescribeStackDriftDetectionStatus(const Model::DescribeStackDriftDetectionStatusRequest& request) const;
 
        template<typename DescribeStackDriftDetectionStatusRequestT = Model::DescribeStackDriftDetectionStatusRequest>
        Model::DescribeStackDriftDetectionStatusOutcomeCallable DescribeStackDriftDetectionStatusCallable(const DescribeStackDriftDetectionStatusRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeStackDriftDetectionStatus, request);
        }
 
        template<typename DescribeStackDriftDetectionStatusRequestT = Model::DescribeStackDriftDetectionStatusRequest>
        void DescribeStackDriftDetectionStatusAsync(const DescribeStackDriftDetectionStatusRequestT& request, const DescribeStackDriftDetectionStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeStackDriftDetectionStatus, request, handler, context);
        }
 
        virtual Model::DescribeStackEventsOutcome DescribeStackEvents(const Model::DescribeStackEventsRequest& request = {}) const;
 
        template<typename DescribeStackEventsRequestT = Model::DescribeStackEventsRequest>
        Model::DescribeStackEventsOutcomeCallable DescribeStackEventsCallable(const DescribeStackEventsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeStackEvents, request);
        }
 
        template<typename DescribeStackEventsRequestT = Model::DescribeStackEventsRequest>
        void DescribeStackEventsAsync(const DescribeStackEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeStackEventsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeStackEvents, request, handler, context);
        }
 
        virtual Model::DescribeStackInstanceOutcome DescribeStackInstance(const Model::DescribeStackInstanceRequest& request) const;
 
        template<typename DescribeStackInstanceRequestT = Model::DescribeStackInstanceRequest>
        Model::DescribeStackInstanceOutcomeCallable DescribeStackInstanceCallable(const DescribeStackInstanceRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeStackInstance, request);
        }
 
        template<typename DescribeStackInstanceRequestT = Model::DescribeStackInstanceRequest>
        void DescribeStackInstanceAsync(const DescribeStackInstanceRequestT& request, const DescribeStackInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeStackInstance, request, handler, context);
        }
 
        virtual Model::DescribeStackResourceOutcome DescribeStackResource(const Model::DescribeStackResourceRequest& request) const;
 
        template<typename DescribeStackResourceRequestT = Model::DescribeStackResourceRequest>
        Model::DescribeStackResourceOutcomeCallable DescribeStackResourceCallable(const DescribeStackResourceRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeStackResource, request);
        }
 
        template<typename DescribeStackResourceRequestT = Model::DescribeStackResourceRequest>
        void DescribeStackResourceAsync(const DescribeStackResourceRequestT& request, const DescribeStackResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeStackResource, request, handler, context);
        }
 
        virtual Model::DescribeStackResourceDriftsOutcome DescribeStackResourceDrifts(const Model::DescribeStackResourceDriftsRequest& request) const;
 
        template<typename DescribeStackResourceDriftsRequestT = Model::DescribeStackResourceDriftsRequest>
        Model::DescribeStackResourceDriftsOutcomeCallable DescribeStackResourceDriftsCallable(const DescribeStackResourceDriftsRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeStackResourceDrifts, request);
        }
 
        template<typename DescribeStackResourceDriftsRequestT = Model::DescribeStackResourceDriftsRequest>
        void DescribeStackResourceDriftsAsync(const DescribeStackResourceDriftsRequestT& request, const DescribeStackResourceDriftsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeStackResourceDrifts, request, handler, context);
        }
 
        virtual Model::DescribeStackResourcesOutcome DescribeStackResources(const Model::DescribeStackResourcesRequest& request = {}) const;
 
        template<typename DescribeStackResourcesRequestT = Model::DescribeStackResourcesRequest>
        Model::DescribeStackResourcesOutcomeCallable DescribeStackResourcesCallable(const DescribeStackResourcesRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeStackResources, request);
        }
 
        template<typename DescribeStackResourcesRequestT = Model::DescribeStackResourcesRequest>
        void DescribeStackResourcesAsync(const DescribeStackResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeStackResourcesRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeStackResources, request, handler, context);
        }
 
        virtual Model::DescribeStackSetOutcome DescribeStackSet(const Model::DescribeStackSetRequest& request) const;
 
        template<typename DescribeStackSetRequestT = Model::DescribeStackSetRequest>
        Model::DescribeStackSetOutcomeCallable DescribeStackSetCallable(const DescribeStackSetRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeStackSet, request);
        }
 
        template<typename DescribeStackSetRequestT = Model::DescribeStackSetRequest>
        void DescribeStackSetAsync(const DescribeStackSetRequestT& request, const DescribeStackSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeStackSet, request, handler, context);
        }
 
        virtual Model::DescribeStackSetOperationOutcome DescribeStackSetOperation(const Model::DescribeStackSetOperationRequest& request) const;
 
        template<typename DescribeStackSetOperationRequestT = Model::DescribeStackSetOperationRequest>
        Model::DescribeStackSetOperationOutcomeCallable DescribeStackSetOperationCallable(const DescribeStackSetOperationRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeStackSetOperation, request);
        }
 
        template<typename DescribeStackSetOperationRequestT = Model::DescribeStackSetOperationRequest>
        void DescribeStackSetOperationAsync(const DescribeStackSetOperationRequestT& request, const DescribeStackSetOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeStackSetOperation, request, handler, context);
        }
 
        virtual Model::DescribeStacksOutcome DescribeStacks(const Model::DescribeStacksRequest& request = {}) const;
 
        template<typename DescribeStacksRequestT = Model::DescribeStacksRequest>
        Model::DescribeStacksOutcomeCallable DescribeStacksCallable(const DescribeStacksRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeStacks, request);
        }
 
        template<typename DescribeStacksRequestT = Model::DescribeStacksRequest>
        void DescribeStacksAsync(const DescribeStacksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeStacksRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeStacks, request, handler, context);
        }
 
        virtual Model::DescribeTypeOutcome DescribeType(const Model::DescribeTypeRequest& request = {}) const;
 
        template<typename DescribeTypeRequestT = Model::DescribeTypeRequest>
        Model::DescribeTypeOutcomeCallable DescribeTypeCallable(const DescribeTypeRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeType, request);
        }
 
        template<typename DescribeTypeRequestT = Model::DescribeTypeRequest>
        void DescribeTypeAsync(const DescribeTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeTypeRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeType, request, handler, context);
        }
 
        virtual Model::DescribeTypeRegistrationOutcome DescribeTypeRegistration(const Model::DescribeTypeRegistrationRequest& request) const;
 
        template<typename DescribeTypeRegistrationRequestT = Model::DescribeTypeRegistrationRequest>
        Model::DescribeTypeRegistrationOutcomeCallable DescribeTypeRegistrationCallable(const DescribeTypeRegistrationRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DescribeTypeRegistration, request);
        }
 
        template<typename DescribeTypeRegistrationRequestT = Model::DescribeTypeRegistrationRequest>
        void DescribeTypeRegistrationAsync(const DescribeTypeRegistrationRequestT& request, const DescribeTypeRegistrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DescribeTypeRegistration, request, handler, context);
        }
 
        virtual Model::DetectStackDriftOutcome DetectStackDrift(const Model::DetectStackDriftRequest& request) const;
 
        template<typename DetectStackDriftRequestT = Model::DetectStackDriftRequest>
        Model::DetectStackDriftOutcomeCallable DetectStackDriftCallable(const DetectStackDriftRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DetectStackDrift, request);
        }
 
        template<typename DetectStackDriftRequestT = Model::DetectStackDriftRequest>
        void DetectStackDriftAsync(const DetectStackDriftRequestT& request, const DetectStackDriftResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DetectStackDrift, request, handler, context);
        }
 
        virtual Model::DetectStackResourceDriftOutcome DetectStackResourceDrift(const Model::DetectStackResourceDriftRequest& request) const;
 
        template<typename DetectStackResourceDriftRequestT = Model::DetectStackResourceDriftRequest>
        Model::DetectStackResourceDriftOutcomeCallable DetectStackResourceDriftCallable(const DetectStackResourceDriftRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DetectStackResourceDrift, request);
        }
 
        template<typename DetectStackResourceDriftRequestT = Model::DetectStackResourceDriftRequest>
        void DetectStackResourceDriftAsync(const DetectStackResourceDriftRequestT& request, const DetectStackResourceDriftResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DetectStackResourceDrift, request, handler, context);
        }
 
        virtual Model::DetectStackSetDriftOutcome DetectStackSetDrift(const Model::DetectStackSetDriftRequest& request) const;
 
        template<typename DetectStackSetDriftRequestT = Model::DetectStackSetDriftRequest>
        Model::DetectStackSetDriftOutcomeCallable DetectStackSetDriftCallable(const DetectStackSetDriftRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::DetectStackSetDrift, request);
        }
 
        template<typename DetectStackSetDriftRequestT = Model::DetectStackSetDriftRequest>
        void DetectStackSetDriftAsync(const DetectStackSetDriftRequestT& request, const DetectStackSetDriftResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::DetectStackSetDrift, request, handler, context);
        }
 
        virtual Model::EstimateTemplateCostOutcome EstimateTemplateCost(const Model::EstimateTemplateCostRequest& request = {}) const;
 
        template<typename EstimateTemplateCostRequestT = Model::EstimateTemplateCostRequest>
        Model::EstimateTemplateCostOutcomeCallable EstimateTemplateCostCallable(const EstimateTemplateCostRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::EstimateTemplateCost, request);
        }
 
        template<typename EstimateTemplateCostRequestT = Model::EstimateTemplateCostRequest>
        void EstimateTemplateCostAsync(const EstimateTemplateCostResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const EstimateTemplateCostRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::EstimateTemplateCost, request, handler, context);
        }
 
        virtual Model::ExecuteChangeSetOutcome ExecuteChangeSet(const Model::ExecuteChangeSetRequest& request) const;
 
        template<typename ExecuteChangeSetRequestT = Model::ExecuteChangeSetRequest>
        Model::ExecuteChangeSetOutcomeCallable ExecuteChangeSetCallable(const ExecuteChangeSetRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ExecuteChangeSet, request);
        }
 
        template<typename ExecuteChangeSetRequestT = Model::ExecuteChangeSetRequest>
        void ExecuteChangeSetAsync(const ExecuteChangeSetRequestT& request, const ExecuteChangeSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ExecuteChangeSet, request, handler, context);
        }
 
        virtual Model::GetGeneratedTemplateOutcome GetGeneratedTemplate(const Model::GetGeneratedTemplateRequest& request) const;
 
        template<typename GetGeneratedTemplateRequestT = Model::GetGeneratedTemplateRequest>
        Model::GetGeneratedTemplateOutcomeCallable GetGeneratedTemplateCallable(const GetGeneratedTemplateRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::GetGeneratedTemplate, request);
        }
 
        template<typename GetGeneratedTemplateRequestT = Model::GetGeneratedTemplateRequest>
        void GetGeneratedTemplateAsync(const GetGeneratedTemplateRequestT& request, const GetGeneratedTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::GetGeneratedTemplate, request, handler, context);
        }
 
        virtual Model::GetStackPolicyOutcome GetStackPolicy(const Model::GetStackPolicyRequest& request) const;
 
        template<typename GetStackPolicyRequestT = Model::GetStackPolicyRequest>
        Model::GetStackPolicyOutcomeCallable GetStackPolicyCallable(const GetStackPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::GetStackPolicy, request);
        }
 
        template<typename GetStackPolicyRequestT = Model::GetStackPolicyRequest>
        void GetStackPolicyAsync(const GetStackPolicyRequestT& request, const GetStackPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::GetStackPolicy, request, handler, context);
        }
 
        virtual Model::GetTemplateOutcome GetTemplate(const Model::GetTemplateRequest& request = {}) const;
 
        template<typename GetTemplateRequestT = Model::GetTemplateRequest>
        Model::GetTemplateOutcomeCallable GetTemplateCallable(const GetTemplateRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::GetTemplate, request);
        }
 
        template<typename GetTemplateRequestT = Model::GetTemplateRequest>
        void GetTemplateAsync(const GetTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetTemplateRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::GetTemplate, request, handler, context);
        }
 
        virtual Model::GetTemplateSummaryOutcome GetTemplateSummary(const Model::GetTemplateSummaryRequest& request = {}) const;
 
        template<typename GetTemplateSummaryRequestT = Model::GetTemplateSummaryRequest>
        Model::GetTemplateSummaryOutcomeCallable GetTemplateSummaryCallable(const GetTemplateSummaryRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::GetTemplateSummary, request);
        }
 
        template<typename GetTemplateSummaryRequestT = Model::GetTemplateSummaryRequest>
        void GetTemplateSummaryAsync(const GetTemplateSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetTemplateSummaryRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::GetTemplateSummary, request, handler, context);
        }
 
        virtual Model::ImportStacksToStackSetOutcome ImportStacksToStackSet(const Model::ImportStacksToStackSetRequest& request) const;
 
        template<typename ImportStacksToStackSetRequestT = Model::ImportStacksToStackSetRequest>
        Model::ImportStacksToStackSetOutcomeCallable ImportStacksToStackSetCallable(const ImportStacksToStackSetRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ImportStacksToStackSet, request);
        }
 
        template<typename ImportStacksToStackSetRequestT = Model::ImportStacksToStackSetRequest>
        void ImportStacksToStackSetAsync(const ImportStacksToStackSetRequestT& request, const ImportStacksToStackSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ImportStacksToStackSet, request, handler, context);
        }
 
        virtual Model::ListChangeSetsOutcome ListChangeSets(const Model::ListChangeSetsRequest& request) const;
 
        template<typename ListChangeSetsRequestT = Model::ListChangeSetsRequest>
        Model::ListChangeSetsOutcomeCallable ListChangeSetsCallable(const ListChangeSetsRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ListChangeSets, request);
        }
 
        template<typename ListChangeSetsRequestT = Model::ListChangeSetsRequest>
        void ListChangeSetsAsync(const ListChangeSetsRequestT& request, const ListChangeSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ListChangeSets, request, handler, context);
        }
 
        virtual Model::ListExportsOutcome ListExports(const Model::ListExportsRequest& request = {}) const;
 
        template<typename ListExportsRequestT = Model::ListExportsRequest>
        Model::ListExportsOutcomeCallable ListExportsCallable(const ListExportsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ListExports, request);
        }
 
        template<typename ListExportsRequestT = Model::ListExportsRequest>
        void ListExportsAsync(const ListExportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListExportsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ListExports, request, handler, context);
        }
 
        virtual Model::ListGeneratedTemplatesOutcome ListGeneratedTemplates(const Model::ListGeneratedTemplatesRequest& request = {}) const;
 
        template<typename ListGeneratedTemplatesRequestT = Model::ListGeneratedTemplatesRequest>
        Model::ListGeneratedTemplatesOutcomeCallable ListGeneratedTemplatesCallable(const ListGeneratedTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ListGeneratedTemplates, request);
        }
 
        template<typename ListGeneratedTemplatesRequestT = Model::ListGeneratedTemplatesRequest>
        void ListGeneratedTemplatesAsync(const ListGeneratedTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGeneratedTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ListGeneratedTemplates, request, handler, context);
        }
 
        virtual Model::ListImportsOutcome ListImports(const Model::ListImportsRequest& request) const;
 
        template<typename ListImportsRequestT = Model::ListImportsRequest>
        Model::ListImportsOutcomeCallable ListImportsCallable(const ListImportsRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ListImports, request);
        }
 
        template<typename ListImportsRequestT = Model::ListImportsRequest>
        void ListImportsAsync(const ListImportsRequestT& request, const ListImportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ListImports, request, handler, context);
        }
 
        virtual Model::ListResourceScanRelatedResourcesOutcome ListResourceScanRelatedResources(const Model::ListResourceScanRelatedResourcesRequest& request) const;
 
        template<typename ListResourceScanRelatedResourcesRequestT = Model::ListResourceScanRelatedResourcesRequest>
        Model::ListResourceScanRelatedResourcesOutcomeCallable ListResourceScanRelatedResourcesCallable(const ListResourceScanRelatedResourcesRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ListResourceScanRelatedResources, request);
        }
 
        template<typename ListResourceScanRelatedResourcesRequestT = Model::ListResourceScanRelatedResourcesRequest>
        void ListResourceScanRelatedResourcesAsync(const ListResourceScanRelatedResourcesRequestT& request, const ListResourceScanRelatedResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ListResourceScanRelatedResources, request, handler, context);
        }
 
        virtual Model::ListResourceScanResourcesOutcome ListResourceScanResources(const Model::ListResourceScanResourcesRequest& request) const;
 
        template<typename ListResourceScanResourcesRequestT = Model::ListResourceScanResourcesRequest>
        Model::ListResourceScanResourcesOutcomeCallable ListResourceScanResourcesCallable(const ListResourceScanResourcesRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ListResourceScanResources, request);
        }
 
        template<typename ListResourceScanResourcesRequestT = Model::ListResourceScanResourcesRequest>
        void ListResourceScanResourcesAsync(const ListResourceScanResourcesRequestT& request, const ListResourceScanResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ListResourceScanResources, request, handler, context);
        }
 
        virtual Model::ListResourceScansOutcome ListResourceScans(const Model::ListResourceScansRequest& request = {}) const;
 
        template<typename ListResourceScansRequestT = Model::ListResourceScansRequest>
        Model::ListResourceScansOutcomeCallable ListResourceScansCallable(const ListResourceScansRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ListResourceScans, request);
        }
 
        template<typename ListResourceScansRequestT = Model::ListResourceScansRequest>
        void ListResourceScansAsync(const ListResourceScansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResourceScansRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ListResourceScans, request, handler, context);
        }
 
        virtual Model::ListStackInstanceResourceDriftsOutcome ListStackInstanceResourceDrifts(const Model::ListStackInstanceResourceDriftsRequest& request) const;
 
        template<typename ListStackInstanceResourceDriftsRequestT = Model::ListStackInstanceResourceDriftsRequest>
        Model::ListStackInstanceResourceDriftsOutcomeCallable ListStackInstanceResourceDriftsCallable(const ListStackInstanceResourceDriftsRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ListStackInstanceResourceDrifts, request);
        }
 
        template<typename ListStackInstanceResourceDriftsRequestT = Model::ListStackInstanceResourceDriftsRequest>
        void ListStackInstanceResourceDriftsAsync(const ListStackInstanceResourceDriftsRequestT& request, const ListStackInstanceResourceDriftsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ListStackInstanceResourceDrifts, request, handler, context);
        }
 
        virtual Model::ListStackInstancesOutcome ListStackInstances(const Model::ListStackInstancesRequest& request) const;
 
        template<typename ListStackInstancesRequestT = Model::ListStackInstancesRequest>
        Model::ListStackInstancesOutcomeCallable ListStackInstancesCallable(const ListStackInstancesRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ListStackInstances, request);
        }
 
        template<typename ListStackInstancesRequestT = Model::ListStackInstancesRequest>
        void ListStackInstancesAsync(const ListStackInstancesRequestT& request, const ListStackInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ListStackInstances, request, handler, context);
        }
 
        virtual Model::ListStackResourcesOutcome ListStackResources(const Model::ListStackResourcesRequest& request) const;
 
        template<typename ListStackResourcesRequestT = Model::ListStackResourcesRequest>
        Model::ListStackResourcesOutcomeCallable ListStackResourcesCallable(const ListStackResourcesRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ListStackResources, request);
        }
 
        template<typename ListStackResourcesRequestT = Model::ListStackResourcesRequest>
        void ListStackResourcesAsync(const ListStackResourcesRequestT& request, const ListStackResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ListStackResources, request, handler, context);
        }
 
        virtual Model::ListStackSetAutoDeploymentTargetsOutcome ListStackSetAutoDeploymentTargets(const Model::ListStackSetAutoDeploymentTargetsRequest& request) const;
 
        template<typename ListStackSetAutoDeploymentTargetsRequestT = Model::ListStackSetAutoDeploymentTargetsRequest>
        Model::ListStackSetAutoDeploymentTargetsOutcomeCallable ListStackSetAutoDeploymentTargetsCallable(const ListStackSetAutoDeploymentTargetsRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ListStackSetAutoDeploymentTargets, request);
        }
 
        template<typename ListStackSetAutoDeploymentTargetsRequestT = Model::ListStackSetAutoDeploymentTargetsRequest>
        void ListStackSetAutoDeploymentTargetsAsync(const ListStackSetAutoDeploymentTargetsRequestT& request, const ListStackSetAutoDeploymentTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ListStackSetAutoDeploymentTargets, request, handler, context);
        }
 
        virtual Model::ListStackSetOperationResultsOutcome ListStackSetOperationResults(const Model::ListStackSetOperationResultsRequest& request) const;
 
        template<typename ListStackSetOperationResultsRequestT = Model::ListStackSetOperationResultsRequest>
        Model::ListStackSetOperationResultsOutcomeCallable ListStackSetOperationResultsCallable(const ListStackSetOperationResultsRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ListStackSetOperationResults, request);
        }
 
        template<typename ListStackSetOperationResultsRequestT = Model::ListStackSetOperationResultsRequest>
        void ListStackSetOperationResultsAsync(const ListStackSetOperationResultsRequestT& request, const ListStackSetOperationResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ListStackSetOperationResults, request, handler, context);
        }
 
        virtual Model::ListStackSetOperationsOutcome ListStackSetOperations(const Model::ListStackSetOperationsRequest& request) const;
 
        template<typename ListStackSetOperationsRequestT = Model::ListStackSetOperationsRequest>
        Model::ListStackSetOperationsOutcomeCallable ListStackSetOperationsCallable(const ListStackSetOperationsRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::ListStackSetOperations, request);
        }
 
        template<typename ListStackSetOperationsRequestT = Model::ListStackSetOperationsRequest>
        void ListStackSetOperationsAsync(const ListStackSetOperationsRequestT& request, const ListStackSetOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::ListStackSetOperations, request, handler, context);
        }
 
        virtual Model::ListStackSetsOutcome ListStackSets(const Model::ListStackSetsRequest& request = {}) const;
 
        template<typename ListStackSetsRequestT = Model::ListStackSetsRequest>
        Model::ListStackSetsOutcomeCallable ListStackSetsCallable(const ListStackSetsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ListStackSets, request);
        }
 
        template<typename ListStackSetsRequestT = Model::ListStackSetsRequest>
        void ListStackSetsAsync(const ListStackSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListStackSetsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ListStackSets, request, handler, context);
        }
 
        virtual Model::ListStacksOutcome ListStacks(const Model::ListStacksRequest& request = {}) const;
 
        template<typename ListStacksRequestT = Model::ListStacksRequest>
        Model::ListStacksOutcomeCallable ListStacksCallable(const ListStacksRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ListStacks, request);
        }
 
        template<typename ListStacksRequestT = Model::ListStacksRequest>
        void ListStacksAsync(const ListStacksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListStacksRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ListStacks, request, handler, context);
        }
 
        virtual Model::ListTypeRegistrationsOutcome ListTypeRegistrations(const Model::ListTypeRegistrationsRequest& request = {}) const;
 
        template<typename ListTypeRegistrationsRequestT = Model::ListTypeRegistrationsRequest>
        Model::ListTypeRegistrationsOutcomeCallable ListTypeRegistrationsCallable(const ListTypeRegistrationsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ListTypeRegistrations, request);
        }
 
        template<typename ListTypeRegistrationsRequestT = Model::ListTypeRegistrationsRequest>
        void ListTypeRegistrationsAsync(const ListTypeRegistrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTypeRegistrationsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ListTypeRegistrations, request, handler, context);
        }
 
        virtual Model::ListTypeVersionsOutcome ListTypeVersions(const Model::ListTypeVersionsRequest& request = {}) const;
 
        template<typename ListTypeVersionsRequestT = Model::ListTypeVersionsRequest>
        Model::ListTypeVersionsOutcomeCallable ListTypeVersionsCallable(const ListTypeVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ListTypeVersions, request);
        }
 
        template<typename ListTypeVersionsRequestT = Model::ListTypeVersionsRequest>
        void ListTypeVersionsAsync(const ListTypeVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTypeVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ListTypeVersions, request, handler, context);
        }
 
        virtual Model::ListTypesOutcome ListTypes(const Model::ListTypesRequest& request = {}) const;
 
        template<typename ListTypesRequestT = Model::ListTypesRequest>
        Model::ListTypesOutcomeCallable ListTypesCallable(const ListTypesRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ListTypes, request);
        }
 
        template<typename ListTypesRequestT = Model::ListTypesRequest>
        void ListTypesAsync(const ListTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTypesRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ListTypes, request, handler, context);
        }
 
        virtual Model::PublishTypeOutcome PublishType(const Model::PublishTypeRequest& request = {}) const;
 
        template<typename PublishTypeRequestT = Model::PublishTypeRequest>
        Model::PublishTypeOutcomeCallable PublishTypeCallable(const PublishTypeRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::PublishType, request);
        }
 
        template<typename PublishTypeRequestT = Model::PublishTypeRequest>
        void PublishTypeAsync(const PublishTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const PublishTypeRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::PublishType, request, handler, context);
        }
 
        virtual Model::RecordHandlerProgressOutcome RecordHandlerProgress(const Model::RecordHandlerProgressRequest& request) const;
 
        template<typename RecordHandlerProgressRequestT = Model::RecordHandlerProgressRequest>
        Model::RecordHandlerProgressOutcomeCallable RecordHandlerProgressCallable(const RecordHandlerProgressRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::RecordHandlerProgress, request);
        }
 
        template<typename RecordHandlerProgressRequestT = Model::RecordHandlerProgressRequest>
        void RecordHandlerProgressAsync(const RecordHandlerProgressRequestT& request, const RecordHandlerProgressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::RecordHandlerProgress, request, handler, context);
        }
 
        virtual Model::RegisterPublisherOutcome RegisterPublisher(const Model::RegisterPublisherRequest& request = {}) const;
 
        template<typename RegisterPublisherRequestT = Model::RegisterPublisherRequest>
        Model::RegisterPublisherOutcomeCallable RegisterPublisherCallable(const RegisterPublisherRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::RegisterPublisher, request);
        }
 
        template<typename RegisterPublisherRequestT = Model::RegisterPublisherRequest>
        void RegisterPublisherAsync(const RegisterPublisherResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RegisterPublisherRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::RegisterPublisher, request, handler, context);
        }
 
        virtual Model::RegisterTypeOutcome RegisterType(const Model::RegisterTypeRequest& request) const;
 
        template<typename RegisterTypeRequestT = Model::RegisterTypeRequest>
        Model::RegisterTypeOutcomeCallable RegisterTypeCallable(const RegisterTypeRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::RegisterType, request);
        }
 
        template<typename RegisterTypeRequestT = Model::RegisterTypeRequest>
        void RegisterTypeAsync(const RegisterTypeRequestT& request, const RegisterTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::RegisterType, request, handler, context);
        }
 
        virtual Model::RollbackStackOutcome RollbackStack(const Model::RollbackStackRequest& request) const;
 
        template<typename RollbackStackRequestT = Model::RollbackStackRequest>
        Model::RollbackStackOutcomeCallable RollbackStackCallable(const RollbackStackRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::RollbackStack, request);
        }
 
        template<typename RollbackStackRequestT = Model::RollbackStackRequest>
        void RollbackStackAsync(const RollbackStackRequestT& request, const RollbackStackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::RollbackStack, request, handler, context);
        }
 
        virtual Model::SetStackPolicyOutcome SetStackPolicy(const Model::SetStackPolicyRequest& request) const;
 
        template<typename SetStackPolicyRequestT = Model::SetStackPolicyRequest>
        Model::SetStackPolicyOutcomeCallable SetStackPolicyCallable(const SetStackPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::SetStackPolicy, request);
        }
 
        template<typename SetStackPolicyRequestT = Model::SetStackPolicyRequest>
        void SetStackPolicyAsync(const SetStackPolicyRequestT& request, const SetStackPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::SetStackPolicy, request, handler, context);
        }
 
        virtual Model::SetTypeConfigurationOutcome SetTypeConfiguration(const Model::SetTypeConfigurationRequest& request) const;
 
        template<typename SetTypeConfigurationRequestT = Model::SetTypeConfigurationRequest>
        Model::SetTypeConfigurationOutcomeCallable SetTypeConfigurationCallable(const SetTypeConfigurationRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::SetTypeConfiguration, request);
        }
 
        template<typename SetTypeConfigurationRequestT = Model::SetTypeConfigurationRequest>
        void SetTypeConfigurationAsync(const SetTypeConfigurationRequestT& request, const SetTypeConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::SetTypeConfiguration, request, handler, context);
        }
 
        virtual Model::SetTypeDefaultVersionOutcome SetTypeDefaultVersion(const Model::SetTypeDefaultVersionRequest& request = {}) const;
 
        template<typename SetTypeDefaultVersionRequestT = Model::SetTypeDefaultVersionRequest>
        Model::SetTypeDefaultVersionOutcomeCallable SetTypeDefaultVersionCallable(const SetTypeDefaultVersionRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::SetTypeDefaultVersion, request);
        }
 
        template<typename SetTypeDefaultVersionRequestT = Model::SetTypeDefaultVersionRequest>
        void SetTypeDefaultVersionAsync(const SetTypeDefaultVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SetTypeDefaultVersionRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::SetTypeDefaultVersion, request, handler, context);
        }
 
        virtual Model::SignalResourceOutcome SignalResource(const Model::SignalResourceRequest& request) const;
 
        template<typename SignalResourceRequestT = Model::SignalResourceRequest>
        Model::SignalResourceOutcomeCallable SignalResourceCallable(const SignalResourceRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::SignalResource, request);
        }
 
        template<typename SignalResourceRequestT = Model::SignalResourceRequest>
        void SignalResourceAsync(const SignalResourceRequestT& request, const SignalResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::SignalResource, request, handler, context);
        }
 
        virtual Model::StartResourceScanOutcome StartResourceScan(const Model::StartResourceScanRequest& request = {}) const;
 
        template<typename StartResourceScanRequestT = Model::StartResourceScanRequest>
        Model::StartResourceScanOutcomeCallable StartResourceScanCallable(const StartResourceScanRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::StartResourceScan, request);
        }
 
        template<typename StartResourceScanRequestT = Model::StartResourceScanRequest>
        void StartResourceScanAsync(const StartResourceScanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const StartResourceScanRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::StartResourceScan, request, handler, context);
        }
 
        virtual Model::StopStackSetOperationOutcome StopStackSetOperation(const Model::StopStackSetOperationRequest& request) const;
 
        template<typename StopStackSetOperationRequestT = Model::StopStackSetOperationRequest>
        Model::StopStackSetOperationOutcomeCallable StopStackSetOperationCallable(const StopStackSetOperationRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::StopStackSetOperation, request);
        }
 
        template<typename StopStackSetOperationRequestT = Model::StopStackSetOperationRequest>
        void StopStackSetOperationAsync(const StopStackSetOperationRequestT& request, const StopStackSetOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::StopStackSetOperation, request, handler, context);
        }
 
        virtual Model::TestTypeOutcome TestType(const Model::TestTypeRequest& request = {}) const;
 
        template<typename TestTypeRequestT = Model::TestTypeRequest>
        Model::TestTypeOutcomeCallable TestTypeCallable(const TestTypeRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::TestType, request);
        }
 
        template<typename TestTypeRequestT = Model::TestTypeRequest>
        void TestTypeAsync(const TestTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const TestTypeRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::TestType, request, handler, context);
        }
 
        virtual Model::UpdateGeneratedTemplateOutcome UpdateGeneratedTemplate(const Model::UpdateGeneratedTemplateRequest& request) const;
 
        template<typename UpdateGeneratedTemplateRequestT = Model::UpdateGeneratedTemplateRequest>
        Model::UpdateGeneratedTemplateOutcomeCallable UpdateGeneratedTemplateCallable(const UpdateGeneratedTemplateRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::UpdateGeneratedTemplate, request);
        }
 
        template<typename UpdateGeneratedTemplateRequestT = Model::UpdateGeneratedTemplateRequest>
        void UpdateGeneratedTemplateAsync(const UpdateGeneratedTemplateRequestT& request, const UpdateGeneratedTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::UpdateGeneratedTemplate, request, handler, context);
        }
 
        virtual Model::UpdateStackOutcome UpdateStack(const Model::UpdateStackRequest& request) const;
 
        template<typename UpdateStackRequestT = Model::UpdateStackRequest>
        Model::UpdateStackOutcomeCallable UpdateStackCallable(const UpdateStackRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::UpdateStack, request);
        }
 
        template<typename UpdateStackRequestT = Model::UpdateStackRequest>
        void UpdateStackAsync(const UpdateStackRequestT& request, const UpdateStackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::UpdateStack, request, handler, context);
        }
 
        virtual Model::UpdateStackInstancesOutcome UpdateStackInstances(const Model::UpdateStackInstancesRequest& request) const;
 
        template<typename UpdateStackInstancesRequestT = Model::UpdateStackInstancesRequest>
        Model::UpdateStackInstancesOutcomeCallable UpdateStackInstancesCallable(const UpdateStackInstancesRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::UpdateStackInstances, request);
        }
 
        template<typename UpdateStackInstancesRequestT = Model::UpdateStackInstancesRequest>
        void UpdateStackInstancesAsync(const UpdateStackInstancesRequestT& request, const UpdateStackInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::UpdateStackInstances, request, handler, context);
        }
 
        virtual Model::UpdateStackSetOutcome UpdateStackSet(const Model::UpdateStackSetRequest& request) const;
 
        template<typename UpdateStackSetRequestT = Model::UpdateStackSetRequest>
        Model::UpdateStackSetOutcomeCallable UpdateStackSetCallable(const UpdateStackSetRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::UpdateStackSet, request);
        }
 
        template<typename UpdateStackSetRequestT = Model::UpdateStackSetRequest>
        void UpdateStackSetAsync(const UpdateStackSetRequestT& request, const UpdateStackSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::UpdateStackSet, request, handler, context);
        }
 
        virtual Model::UpdateTerminationProtectionOutcome UpdateTerminationProtection(const Model::UpdateTerminationProtectionRequest& request) const;
 
        template<typename UpdateTerminationProtectionRequestT = Model::UpdateTerminationProtectionRequest>
        Model::UpdateTerminationProtectionOutcomeCallable UpdateTerminationProtectionCallable(const UpdateTerminationProtectionRequestT& request) const
        {
            return SubmitCallable(&CloudFormationClient::UpdateTerminationProtection, request);
        }
 
        template<typename UpdateTerminationProtectionRequestT = Model::UpdateTerminationProtectionRequest>
        void UpdateTerminationProtectionAsync(const UpdateTerminationProtectionRequestT& request, const UpdateTerminationProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudFormationClient::UpdateTerminationProtection, request, handler, context);
        }
 
        virtual Model::ValidateTemplateOutcome ValidateTemplate(const Model::ValidateTemplateRequest& request = {}) const;
 
        template<typename ValidateTemplateRequestT = Model::ValidateTemplateRequest>
        Model::ValidateTemplateOutcomeCallable ValidateTemplateCallable(const ValidateTemplateRequestT& request = {}) const
        {
            return SubmitCallable(&CloudFormationClient::ValidateTemplate, request);
        }
 
        template<typename ValidateTemplateRequestT = Model::ValidateTemplateRequest>
        void ValidateTemplateAsync(const ValidateTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ValidateTemplateRequestT& request = {}) const
        {
            return SubmitAsync(&CloudFormationClient::ValidateTemplate, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<CloudFormationEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudFormationClient>;
        void init(const CloudFormationClientConfiguration& clientConfiguration);
 
        CloudFormationClientConfiguration m_clientConfiguration;
        std::shared_ptr<CloudFormationEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CloudFormation
} // namespace Aws