OpsWorksClient.h

 
#pragma once
#include <aws/opsworks/OpsWorks_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/opsworks/OpsWorksServiceClientModel.h>
 
namespace Aws
{
namespace OpsWorks
{
  class AWS_OPSWORKS_API OpsWorksClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<OpsWorksClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef OpsWorksClientConfiguration ClientConfigurationType;
      typedef OpsWorksEndpointProvider EndpointProviderType;
 
        OpsWorksClient(const Aws::OpsWorks::OpsWorksClientConfiguration& clientConfiguration = Aws::OpsWorks::OpsWorksClientConfiguration(),
                       std::shared_ptr<OpsWorksEndpointProviderBase> endpointProvider = nullptr);
 
        OpsWorksClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<OpsWorksEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::OpsWorks::OpsWorksClientConfiguration& clientConfiguration = Aws::OpsWorks::OpsWorksClientConfiguration());
 
        OpsWorksClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<OpsWorksEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::OpsWorks::OpsWorksClientConfiguration& clientConfiguration = Aws::OpsWorks::OpsWorksClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        OpsWorksClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        OpsWorksClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        OpsWorksClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~OpsWorksClient();
 
        virtual Model::AssignInstanceOutcome AssignInstance(const Model::AssignInstanceRequest& request) const;
 
        template<typename AssignInstanceRequestT = Model::AssignInstanceRequest>
        Model::AssignInstanceOutcomeCallable AssignInstanceCallable(const AssignInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::AssignInstance, request);
        }
 
        template<typename AssignInstanceRequestT = Model::AssignInstanceRequest>
        void AssignInstanceAsync(const AssignInstanceRequestT& request, const AssignInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::AssignInstance, request, handler, context);
        }
 
        virtual Model::AssignVolumeOutcome AssignVolume(const Model::AssignVolumeRequest& request) const;
 
        template<typename AssignVolumeRequestT = Model::AssignVolumeRequest>
        Model::AssignVolumeOutcomeCallable AssignVolumeCallable(const AssignVolumeRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::AssignVolume, request);
        }
 
        template<typename AssignVolumeRequestT = Model::AssignVolumeRequest>
        void AssignVolumeAsync(const AssignVolumeRequestT& request, const AssignVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::AssignVolume, request, handler, context);
        }
 
        virtual Model::AssociateElasticIpOutcome AssociateElasticIp(const Model::AssociateElasticIpRequest& request) const;
 
        template<typename AssociateElasticIpRequestT = Model::AssociateElasticIpRequest>
        Model::AssociateElasticIpOutcomeCallable AssociateElasticIpCallable(const AssociateElasticIpRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::AssociateElasticIp, request);
        }
 
        template<typename AssociateElasticIpRequestT = Model::AssociateElasticIpRequest>
        void AssociateElasticIpAsync(const AssociateElasticIpRequestT& request, const AssociateElasticIpResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::AssociateElasticIp, request, handler, context);
        }
 
        virtual Model::AttachElasticLoadBalancerOutcome AttachElasticLoadBalancer(const Model::AttachElasticLoadBalancerRequest& request) const;
 
        template<typename AttachElasticLoadBalancerRequestT = Model::AttachElasticLoadBalancerRequest>
        Model::AttachElasticLoadBalancerOutcomeCallable AttachElasticLoadBalancerCallable(const AttachElasticLoadBalancerRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::AttachElasticLoadBalancer, request);
        }
 
        template<typename AttachElasticLoadBalancerRequestT = Model::AttachElasticLoadBalancerRequest>
        void AttachElasticLoadBalancerAsync(const AttachElasticLoadBalancerRequestT& request, const AttachElasticLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::AttachElasticLoadBalancer, request, handler, context);
        }
 
        virtual Model::CloneStackOutcome CloneStack(const Model::CloneStackRequest& request) const;
 
        template<typename CloneStackRequestT = Model::CloneStackRequest>
        Model::CloneStackOutcomeCallable CloneStackCallable(const CloneStackRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::CloneStack, request);
        }
 
        template<typename CloneStackRequestT = Model::CloneStackRequest>
        void CloneStackAsync(const CloneStackRequestT& request, const CloneStackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::CloneStack, request, handler, context);
        }
 
        virtual Model::CreateAppOutcome CreateApp(const Model::CreateAppRequest& request) const;
 
        template<typename CreateAppRequestT = Model::CreateAppRequest>
        Model::CreateAppOutcomeCallable CreateAppCallable(const CreateAppRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::CreateApp, request);
        }
 
        template<typename CreateAppRequestT = Model::CreateAppRequest>
        void CreateAppAsync(const CreateAppRequestT& request, const CreateAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::CreateApp, request, handler, context);
        }
 
        virtual Model::CreateDeploymentOutcome CreateDeployment(const Model::CreateDeploymentRequest& request) const;
 
        template<typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
        Model::CreateDeploymentOutcomeCallable CreateDeploymentCallable(const CreateDeploymentRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::CreateDeployment, request);
        }
 
        template<typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
        void CreateDeploymentAsync(const CreateDeploymentRequestT& request, const CreateDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::CreateDeployment, request, handler, context);
        }
 
        virtual Model::CreateInstanceOutcome CreateInstance(const Model::CreateInstanceRequest& request) const;
 
        template<typename CreateInstanceRequestT = Model::CreateInstanceRequest>
        Model::CreateInstanceOutcomeCallable CreateInstanceCallable(const CreateInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::CreateInstance, request);
        }
 
        template<typename CreateInstanceRequestT = Model::CreateInstanceRequest>
        void CreateInstanceAsync(const CreateInstanceRequestT& request, const CreateInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::CreateInstance, request, handler, context);
        }
 
        virtual Model::CreateLayerOutcome CreateLayer(const Model::CreateLayerRequest& request) const;
 
        template<typename CreateLayerRequestT = Model::CreateLayerRequest>
        Model::CreateLayerOutcomeCallable CreateLayerCallable(const CreateLayerRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::CreateLayer, request);
        }
 
        template<typename CreateLayerRequestT = Model::CreateLayerRequest>
        void CreateLayerAsync(const CreateLayerRequestT& request, const CreateLayerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::CreateLayer, 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(&OpsWorksClient::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(&OpsWorksClient::CreateStack, request, handler, context);
        }
 
        virtual Model::CreateUserProfileOutcome CreateUserProfile(const Model::CreateUserProfileRequest& request) const;
 
        template<typename CreateUserProfileRequestT = Model::CreateUserProfileRequest>
        Model::CreateUserProfileOutcomeCallable CreateUserProfileCallable(const CreateUserProfileRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::CreateUserProfile, request);
        }
 
        template<typename CreateUserProfileRequestT = Model::CreateUserProfileRequest>
        void CreateUserProfileAsync(const CreateUserProfileRequestT& request, const CreateUserProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::CreateUserProfile, request, handler, context);
        }
 
        virtual Model::DeleteAppOutcome DeleteApp(const Model::DeleteAppRequest& request) const;
 
        template<typename DeleteAppRequestT = Model::DeleteAppRequest>
        Model::DeleteAppOutcomeCallable DeleteAppCallable(const DeleteAppRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DeleteApp, request);
        }
 
        template<typename DeleteAppRequestT = Model::DeleteAppRequest>
        void DeleteAppAsync(const DeleteAppRequestT& request, const DeleteAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DeleteApp, request, handler, context);
        }
 
        virtual Model::DeleteInstanceOutcome DeleteInstance(const Model::DeleteInstanceRequest& request) const;
 
        template<typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
        Model::DeleteInstanceOutcomeCallable DeleteInstanceCallable(const DeleteInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DeleteInstance, request);
        }
 
        template<typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
        void DeleteInstanceAsync(const DeleteInstanceRequestT& request, const DeleteInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DeleteInstance, request, handler, context);
        }
 
        virtual Model::DeleteLayerOutcome DeleteLayer(const Model::DeleteLayerRequest& request) const;
 
        template<typename DeleteLayerRequestT = Model::DeleteLayerRequest>
        Model::DeleteLayerOutcomeCallable DeleteLayerCallable(const DeleteLayerRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DeleteLayer, request);
        }
 
        template<typename DeleteLayerRequestT = Model::DeleteLayerRequest>
        void DeleteLayerAsync(const DeleteLayerRequestT& request, const DeleteLayerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DeleteLayer, 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(&OpsWorksClient::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(&OpsWorksClient::DeleteStack, request, handler, context);
        }
 
        virtual Model::DeleteUserProfileOutcome DeleteUserProfile(const Model::DeleteUserProfileRequest& request) const;
 
        template<typename DeleteUserProfileRequestT = Model::DeleteUserProfileRequest>
        Model::DeleteUserProfileOutcomeCallable DeleteUserProfileCallable(const DeleteUserProfileRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DeleteUserProfile, request);
        }
 
        template<typename DeleteUserProfileRequestT = Model::DeleteUserProfileRequest>
        void DeleteUserProfileAsync(const DeleteUserProfileRequestT& request, const DeleteUserProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DeleteUserProfile, request, handler, context);
        }
 
        virtual Model::DeregisterEcsClusterOutcome DeregisterEcsCluster(const Model::DeregisterEcsClusterRequest& request) const;
 
        template<typename DeregisterEcsClusterRequestT = Model::DeregisterEcsClusterRequest>
        Model::DeregisterEcsClusterOutcomeCallable DeregisterEcsClusterCallable(const DeregisterEcsClusterRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DeregisterEcsCluster, request);
        }
 
        template<typename DeregisterEcsClusterRequestT = Model::DeregisterEcsClusterRequest>
        void DeregisterEcsClusterAsync(const DeregisterEcsClusterRequestT& request, const DeregisterEcsClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DeregisterEcsCluster, request, handler, context);
        }
 
        virtual Model::DeregisterElasticIpOutcome DeregisterElasticIp(const Model::DeregisterElasticIpRequest& request) const;
 
        template<typename DeregisterElasticIpRequestT = Model::DeregisterElasticIpRequest>
        Model::DeregisterElasticIpOutcomeCallable DeregisterElasticIpCallable(const DeregisterElasticIpRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DeregisterElasticIp, request);
        }
 
        template<typename DeregisterElasticIpRequestT = Model::DeregisterElasticIpRequest>
        void DeregisterElasticIpAsync(const DeregisterElasticIpRequestT& request, const DeregisterElasticIpResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DeregisterElasticIp, request, handler, context);
        }
 
        virtual Model::DeregisterInstanceOutcome DeregisterInstance(const Model::DeregisterInstanceRequest& request) const;
 
        template<typename DeregisterInstanceRequestT = Model::DeregisterInstanceRequest>
        Model::DeregisterInstanceOutcomeCallable DeregisterInstanceCallable(const DeregisterInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DeregisterInstance, request);
        }
 
        template<typename DeregisterInstanceRequestT = Model::DeregisterInstanceRequest>
        void DeregisterInstanceAsync(const DeregisterInstanceRequestT& request, const DeregisterInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DeregisterInstance, request, handler, context);
        }
 
        virtual Model::DeregisterRdsDbInstanceOutcome DeregisterRdsDbInstance(const Model::DeregisterRdsDbInstanceRequest& request) const;
 
        template<typename DeregisterRdsDbInstanceRequestT = Model::DeregisterRdsDbInstanceRequest>
        Model::DeregisterRdsDbInstanceOutcomeCallable DeregisterRdsDbInstanceCallable(const DeregisterRdsDbInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DeregisterRdsDbInstance, request);
        }
 
        template<typename DeregisterRdsDbInstanceRequestT = Model::DeregisterRdsDbInstanceRequest>
        void DeregisterRdsDbInstanceAsync(const DeregisterRdsDbInstanceRequestT& request, const DeregisterRdsDbInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DeregisterRdsDbInstance, request, handler, context);
        }
 
        virtual Model::DeregisterVolumeOutcome DeregisterVolume(const Model::DeregisterVolumeRequest& request) const;
 
        template<typename DeregisterVolumeRequestT = Model::DeregisterVolumeRequest>
        Model::DeregisterVolumeOutcomeCallable DeregisterVolumeCallable(const DeregisterVolumeRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DeregisterVolume, request);
        }
 
        template<typename DeregisterVolumeRequestT = Model::DeregisterVolumeRequest>
        void DeregisterVolumeAsync(const DeregisterVolumeRequestT& request, const DeregisterVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DeregisterVolume, request, handler, context);
        }
 
        virtual Model::DescribeAgentVersionsOutcome DescribeAgentVersions(const Model::DescribeAgentVersionsRequest& request = {}) const;
 
        template<typename DescribeAgentVersionsRequestT = Model::DescribeAgentVersionsRequest>
        Model::DescribeAgentVersionsOutcomeCallable DescribeAgentVersionsCallable(const DescribeAgentVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeAgentVersions, request);
        }
 
        template<typename DescribeAgentVersionsRequestT = Model::DescribeAgentVersionsRequest>
        void DescribeAgentVersionsAsync(const DescribeAgentVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAgentVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeAgentVersions, request, handler, context);
        }
 
        virtual Model::DescribeAppsOutcome DescribeApps(const Model::DescribeAppsRequest& request = {}) const;
 
        template<typename DescribeAppsRequestT = Model::DescribeAppsRequest>
        Model::DescribeAppsOutcomeCallable DescribeAppsCallable(const DescribeAppsRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeApps, request);
        }
 
        template<typename DescribeAppsRequestT = Model::DescribeAppsRequest>
        void DescribeAppsAsync(const DescribeAppsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAppsRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeApps, request, handler, context);
        }
 
        virtual Model::DescribeCommandsOutcome DescribeCommands(const Model::DescribeCommandsRequest& request = {}) const;
 
        template<typename DescribeCommandsRequestT = Model::DescribeCommandsRequest>
        Model::DescribeCommandsOutcomeCallable DescribeCommandsCallable(const DescribeCommandsRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeCommands, request);
        }
 
        template<typename DescribeCommandsRequestT = Model::DescribeCommandsRequest>
        void DescribeCommandsAsync(const DescribeCommandsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCommandsRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeCommands, request, handler, context);
        }
 
        virtual Model::DescribeDeploymentsOutcome DescribeDeployments(const Model::DescribeDeploymentsRequest& request = {}) const;
 
        template<typename DescribeDeploymentsRequestT = Model::DescribeDeploymentsRequest>
        Model::DescribeDeploymentsOutcomeCallable DescribeDeploymentsCallable(const DescribeDeploymentsRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeDeployments, request);
        }
 
        template<typename DescribeDeploymentsRequestT = Model::DescribeDeploymentsRequest>
        void DescribeDeploymentsAsync(const DescribeDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDeploymentsRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeDeployments, request, handler, context);
        }
 
        virtual Model::DescribeEcsClustersOutcome DescribeEcsClusters(const Model::DescribeEcsClustersRequest& request = {}) const;
 
        template<typename DescribeEcsClustersRequestT = Model::DescribeEcsClustersRequest>
        Model::DescribeEcsClustersOutcomeCallable DescribeEcsClustersCallable(const DescribeEcsClustersRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeEcsClusters, request);
        }
 
        template<typename DescribeEcsClustersRequestT = Model::DescribeEcsClustersRequest>
        void DescribeEcsClustersAsync(const DescribeEcsClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEcsClustersRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeEcsClusters, request, handler, context);
        }
 
        virtual Model::DescribeElasticIpsOutcome DescribeElasticIps(const Model::DescribeElasticIpsRequest& request = {}) const;
 
        template<typename DescribeElasticIpsRequestT = Model::DescribeElasticIpsRequest>
        Model::DescribeElasticIpsOutcomeCallable DescribeElasticIpsCallable(const DescribeElasticIpsRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeElasticIps, request);
        }
 
        template<typename DescribeElasticIpsRequestT = Model::DescribeElasticIpsRequest>
        void DescribeElasticIpsAsync(const DescribeElasticIpsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeElasticIpsRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeElasticIps, request, handler, context);
        }
 
        virtual Model::DescribeElasticLoadBalancersOutcome DescribeElasticLoadBalancers(const Model::DescribeElasticLoadBalancersRequest& request = {}) const;
 
        template<typename DescribeElasticLoadBalancersRequestT = Model::DescribeElasticLoadBalancersRequest>
        Model::DescribeElasticLoadBalancersOutcomeCallable DescribeElasticLoadBalancersCallable(const DescribeElasticLoadBalancersRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeElasticLoadBalancers, request);
        }
 
        template<typename DescribeElasticLoadBalancersRequestT = Model::DescribeElasticLoadBalancersRequest>
        void DescribeElasticLoadBalancersAsync(const DescribeElasticLoadBalancersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeElasticLoadBalancersRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeElasticLoadBalancers, request, handler, context);
        }
 
        virtual Model::DescribeInstancesOutcome DescribeInstances(const Model::DescribeInstancesRequest& request = {}) const;
 
        template<typename DescribeInstancesRequestT = Model::DescribeInstancesRequest>
        Model::DescribeInstancesOutcomeCallable DescribeInstancesCallable(const DescribeInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeInstances, request);
        }
 
        template<typename DescribeInstancesRequestT = Model::DescribeInstancesRequest>
        void DescribeInstancesAsync(const DescribeInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeInstances, request, handler, context);
        }
 
        virtual Model::DescribeLayersOutcome DescribeLayers(const Model::DescribeLayersRequest& request = {}) const;
 
        template<typename DescribeLayersRequestT = Model::DescribeLayersRequest>
        Model::DescribeLayersOutcomeCallable DescribeLayersCallable(const DescribeLayersRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeLayers, request);
        }
 
        template<typename DescribeLayersRequestT = Model::DescribeLayersRequest>
        void DescribeLayersAsync(const DescribeLayersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLayersRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeLayers, request, handler, context);
        }
 
        virtual Model::DescribeLoadBasedAutoScalingOutcome DescribeLoadBasedAutoScaling(const Model::DescribeLoadBasedAutoScalingRequest& request) const;
 
        template<typename DescribeLoadBasedAutoScalingRequestT = Model::DescribeLoadBasedAutoScalingRequest>
        Model::DescribeLoadBasedAutoScalingOutcomeCallable DescribeLoadBasedAutoScalingCallable(const DescribeLoadBasedAutoScalingRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeLoadBasedAutoScaling, request);
        }
 
        template<typename DescribeLoadBasedAutoScalingRequestT = Model::DescribeLoadBasedAutoScalingRequest>
        void DescribeLoadBasedAutoScalingAsync(const DescribeLoadBasedAutoScalingRequestT& request, const DescribeLoadBasedAutoScalingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeLoadBasedAutoScaling, request, handler, context);
        }
 
        virtual Model::DescribeMyUserProfileOutcome DescribeMyUserProfile(const Model::DescribeMyUserProfileRequest& request = {}) const;
 
        template<typename DescribeMyUserProfileRequestT = Model::DescribeMyUserProfileRequest>
        Model::DescribeMyUserProfileOutcomeCallable DescribeMyUserProfileCallable(const DescribeMyUserProfileRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeMyUserProfile, request);
        }
 
        template<typename DescribeMyUserProfileRequestT = Model::DescribeMyUserProfileRequest>
        void DescribeMyUserProfileAsync(const DescribeMyUserProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeMyUserProfileRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeMyUserProfile, request, handler, context);
        }
 
        virtual Model::DescribeOperatingSystemsOutcome DescribeOperatingSystems(const Model::DescribeOperatingSystemsRequest& request = {}) const;
 
        template<typename DescribeOperatingSystemsRequestT = Model::DescribeOperatingSystemsRequest>
        Model::DescribeOperatingSystemsOutcomeCallable DescribeOperatingSystemsCallable(const DescribeOperatingSystemsRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeOperatingSystems, request);
        }
 
        template<typename DescribeOperatingSystemsRequestT = Model::DescribeOperatingSystemsRequest>
        void DescribeOperatingSystemsAsync(const DescribeOperatingSystemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeOperatingSystemsRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeOperatingSystems, request, handler, context);
        }
 
        virtual Model::DescribePermissionsOutcome DescribePermissions(const Model::DescribePermissionsRequest& request = {}) const;
 
        template<typename DescribePermissionsRequestT = Model::DescribePermissionsRequest>
        Model::DescribePermissionsOutcomeCallable DescribePermissionsCallable(const DescribePermissionsRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribePermissions, request);
        }
 
        template<typename DescribePermissionsRequestT = Model::DescribePermissionsRequest>
        void DescribePermissionsAsync(const DescribePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribePermissionsRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribePermissions, request, handler, context);
        }
 
        virtual Model::DescribeRaidArraysOutcome DescribeRaidArrays(const Model::DescribeRaidArraysRequest& request = {}) const;
 
        template<typename DescribeRaidArraysRequestT = Model::DescribeRaidArraysRequest>
        Model::DescribeRaidArraysOutcomeCallable DescribeRaidArraysCallable(const DescribeRaidArraysRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeRaidArrays, request);
        }
 
        template<typename DescribeRaidArraysRequestT = Model::DescribeRaidArraysRequest>
        void DescribeRaidArraysAsync(const DescribeRaidArraysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeRaidArraysRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeRaidArrays, request, handler, context);
        }
 
        virtual Model::DescribeRdsDbInstancesOutcome DescribeRdsDbInstances(const Model::DescribeRdsDbInstancesRequest& request) const;
 
        template<typename DescribeRdsDbInstancesRequestT = Model::DescribeRdsDbInstancesRequest>
        Model::DescribeRdsDbInstancesOutcomeCallable DescribeRdsDbInstancesCallable(const DescribeRdsDbInstancesRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeRdsDbInstances, request);
        }
 
        template<typename DescribeRdsDbInstancesRequestT = Model::DescribeRdsDbInstancesRequest>
        void DescribeRdsDbInstancesAsync(const DescribeRdsDbInstancesRequestT& request, const DescribeRdsDbInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeRdsDbInstances, request, handler, context);
        }
 
        virtual Model::DescribeServiceErrorsOutcome DescribeServiceErrors(const Model::DescribeServiceErrorsRequest& request = {}) const;
 
        template<typename DescribeServiceErrorsRequestT = Model::DescribeServiceErrorsRequest>
        Model::DescribeServiceErrorsOutcomeCallable DescribeServiceErrorsCallable(const DescribeServiceErrorsRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeServiceErrors, request);
        }
 
        template<typename DescribeServiceErrorsRequestT = Model::DescribeServiceErrorsRequest>
        void DescribeServiceErrorsAsync(const DescribeServiceErrorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeServiceErrorsRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeServiceErrors, request, handler, context);
        }
 
        virtual Model::DescribeStackProvisioningParametersOutcome DescribeStackProvisioningParameters(const Model::DescribeStackProvisioningParametersRequest& request) const;
 
        template<typename DescribeStackProvisioningParametersRequestT = Model::DescribeStackProvisioningParametersRequest>
        Model::DescribeStackProvisioningParametersOutcomeCallable DescribeStackProvisioningParametersCallable(const DescribeStackProvisioningParametersRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeStackProvisioningParameters, request);
        }
 
        template<typename DescribeStackProvisioningParametersRequestT = Model::DescribeStackProvisioningParametersRequest>
        void DescribeStackProvisioningParametersAsync(const DescribeStackProvisioningParametersRequestT& request, const DescribeStackProvisioningParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeStackProvisioningParameters, request, handler, context);
        }
 
        virtual Model::DescribeStackSummaryOutcome DescribeStackSummary(const Model::DescribeStackSummaryRequest& request) const;
 
        template<typename DescribeStackSummaryRequestT = Model::DescribeStackSummaryRequest>
        Model::DescribeStackSummaryOutcomeCallable DescribeStackSummaryCallable(const DescribeStackSummaryRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeStackSummary, request);
        }
 
        template<typename DescribeStackSummaryRequestT = Model::DescribeStackSummaryRequest>
        void DescribeStackSummaryAsync(const DescribeStackSummaryRequestT& request, const DescribeStackSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeStackSummary, 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(&OpsWorksClient::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(&OpsWorksClient::DescribeStacks, request, handler, context);
        }
 
        virtual Model::DescribeTimeBasedAutoScalingOutcome DescribeTimeBasedAutoScaling(const Model::DescribeTimeBasedAutoScalingRequest& request) const;
 
        template<typename DescribeTimeBasedAutoScalingRequestT = Model::DescribeTimeBasedAutoScalingRequest>
        Model::DescribeTimeBasedAutoScalingOutcomeCallable DescribeTimeBasedAutoScalingCallable(const DescribeTimeBasedAutoScalingRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeTimeBasedAutoScaling, request);
        }
 
        template<typename DescribeTimeBasedAutoScalingRequestT = Model::DescribeTimeBasedAutoScalingRequest>
        void DescribeTimeBasedAutoScalingAsync(const DescribeTimeBasedAutoScalingRequestT& request, const DescribeTimeBasedAutoScalingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeTimeBasedAutoScaling, request, handler, context);
        }
 
        virtual Model::DescribeUserProfilesOutcome DescribeUserProfiles(const Model::DescribeUserProfilesRequest& request = {}) const;
 
        template<typename DescribeUserProfilesRequestT = Model::DescribeUserProfilesRequest>
        Model::DescribeUserProfilesOutcomeCallable DescribeUserProfilesCallable(const DescribeUserProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeUserProfiles, request);
        }
 
        template<typename DescribeUserProfilesRequestT = Model::DescribeUserProfilesRequest>
        void DescribeUserProfilesAsync(const DescribeUserProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeUserProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeUserProfiles, request, handler, context);
        }
 
        virtual Model::DescribeVolumesOutcome DescribeVolumes(const Model::DescribeVolumesRequest& request = {}) const;
 
        template<typename DescribeVolumesRequestT = Model::DescribeVolumesRequest>
        Model::DescribeVolumesOutcomeCallable DescribeVolumesCallable(const DescribeVolumesRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::DescribeVolumes, request);
        }
 
        template<typename DescribeVolumesRequestT = Model::DescribeVolumesRequest>
        void DescribeVolumesAsync(const DescribeVolumesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeVolumesRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::DescribeVolumes, request, handler, context);
        }
 
        virtual Model::DetachElasticLoadBalancerOutcome DetachElasticLoadBalancer(const Model::DetachElasticLoadBalancerRequest& request) const;
 
        template<typename DetachElasticLoadBalancerRequestT = Model::DetachElasticLoadBalancerRequest>
        Model::DetachElasticLoadBalancerOutcomeCallable DetachElasticLoadBalancerCallable(const DetachElasticLoadBalancerRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DetachElasticLoadBalancer, request);
        }
 
        template<typename DetachElasticLoadBalancerRequestT = Model::DetachElasticLoadBalancerRequest>
        void DetachElasticLoadBalancerAsync(const DetachElasticLoadBalancerRequestT& request, const DetachElasticLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DetachElasticLoadBalancer, request, handler, context);
        }
 
        virtual Model::DisassociateElasticIpOutcome DisassociateElasticIp(const Model::DisassociateElasticIpRequest& request) const;
 
        template<typename DisassociateElasticIpRequestT = Model::DisassociateElasticIpRequest>
        Model::DisassociateElasticIpOutcomeCallable DisassociateElasticIpCallable(const DisassociateElasticIpRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::DisassociateElasticIp, request);
        }
 
        template<typename DisassociateElasticIpRequestT = Model::DisassociateElasticIpRequest>
        void DisassociateElasticIpAsync(const DisassociateElasticIpRequestT& request, const DisassociateElasticIpResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::DisassociateElasticIp, request, handler, context);
        }
 
        virtual Model::GetHostnameSuggestionOutcome GetHostnameSuggestion(const Model::GetHostnameSuggestionRequest& request) const;
 
        template<typename GetHostnameSuggestionRequestT = Model::GetHostnameSuggestionRequest>
        Model::GetHostnameSuggestionOutcomeCallable GetHostnameSuggestionCallable(const GetHostnameSuggestionRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::GetHostnameSuggestion, request);
        }
 
        template<typename GetHostnameSuggestionRequestT = Model::GetHostnameSuggestionRequest>
        void GetHostnameSuggestionAsync(const GetHostnameSuggestionRequestT& request, const GetHostnameSuggestionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::GetHostnameSuggestion, request, handler, context);
        }
 
        virtual Model::GrantAccessOutcome GrantAccess(const Model::GrantAccessRequest& request) const;
 
        template<typename GrantAccessRequestT = Model::GrantAccessRequest>
        Model::GrantAccessOutcomeCallable GrantAccessCallable(const GrantAccessRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::GrantAccess, request);
        }
 
        template<typename GrantAccessRequestT = Model::GrantAccessRequest>
        void GrantAccessAsync(const GrantAccessRequestT& request, const GrantAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::GrantAccess, request, handler, context);
        }
 
        virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
 
        template<typename ListTagsRequestT = Model::ListTagsRequest>
        Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::ListTags, request);
        }
 
        template<typename ListTagsRequestT = Model::ListTagsRequest>
        void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::ListTags, request, handler, context);
        }
 
        virtual Model::RebootInstanceOutcome RebootInstance(const Model::RebootInstanceRequest& request) const;
 
        template<typename RebootInstanceRequestT = Model::RebootInstanceRequest>
        Model::RebootInstanceOutcomeCallable RebootInstanceCallable(const RebootInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::RebootInstance, request);
        }
 
        template<typename RebootInstanceRequestT = Model::RebootInstanceRequest>
        void RebootInstanceAsync(const RebootInstanceRequestT& request, const RebootInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::RebootInstance, request, handler, context);
        }
 
        virtual Model::RegisterEcsClusterOutcome RegisterEcsCluster(const Model::RegisterEcsClusterRequest& request) const;
 
        template<typename RegisterEcsClusterRequestT = Model::RegisterEcsClusterRequest>
        Model::RegisterEcsClusterOutcomeCallable RegisterEcsClusterCallable(const RegisterEcsClusterRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::RegisterEcsCluster, request);
        }
 
        template<typename RegisterEcsClusterRequestT = Model::RegisterEcsClusterRequest>
        void RegisterEcsClusterAsync(const RegisterEcsClusterRequestT& request, const RegisterEcsClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::RegisterEcsCluster, request, handler, context);
        }
 
        virtual Model::RegisterElasticIpOutcome RegisterElasticIp(const Model::RegisterElasticIpRequest& request) const;
 
        template<typename RegisterElasticIpRequestT = Model::RegisterElasticIpRequest>
        Model::RegisterElasticIpOutcomeCallable RegisterElasticIpCallable(const RegisterElasticIpRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::RegisterElasticIp, request);
        }
 
        template<typename RegisterElasticIpRequestT = Model::RegisterElasticIpRequest>
        void RegisterElasticIpAsync(const RegisterElasticIpRequestT& request, const RegisterElasticIpResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::RegisterElasticIp, request, handler, context);
        }
 
        virtual Model::RegisterInstanceOutcome RegisterInstance(const Model::RegisterInstanceRequest& request) const;
 
        template<typename RegisterInstanceRequestT = Model::RegisterInstanceRequest>
        Model::RegisterInstanceOutcomeCallable RegisterInstanceCallable(const RegisterInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::RegisterInstance, request);
        }
 
        template<typename RegisterInstanceRequestT = Model::RegisterInstanceRequest>
        void RegisterInstanceAsync(const RegisterInstanceRequestT& request, const RegisterInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::RegisterInstance, request, handler, context);
        }
 
        virtual Model::RegisterRdsDbInstanceOutcome RegisterRdsDbInstance(const Model::RegisterRdsDbInstanceRequest& request) const;
 
        template<typename RegisterRdsDbInstanceRequestT = Model::RegisterRdsDbInstanceRequest>
        Model::RegisterRdsDbInstanceOutcomeCallable RegisterRdsDbInstanceCallable(const RegisterRdsDbInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::RegisterRdsDbInstance, request);
        }
 
        template<typename RegisterRdsDbInstanceRequestT = Model::RegisterRdsDbInstanceRequest>
        void RegisterRdsDbInstanceAsync(const RegisterRdsDbInstanceRequestT& request, const RegisterRdsDbInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::RegisterRdsDbInstance, request, handler, context);
        }
 
        virtual Model::RegisterVolumeOutcome RegisterVolume(const Model::RegisterVolumeRequest& request) const;
 
        template<typename RegisterVolumeRequestT = Model::RegisterVolumeRequest>
        Model::RegisterVolumeOutcomeCallable RegisterVolumeCallable(const RegisterVolumeRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::RegisterVolume, request);
        }
 
        template<typename RegisterVolumeRequestT = Model::RegisterVolumeRequest>
        void RegisterVolumeAsync(const RegisterVolumeRequestT& request, const RegisterVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::RegisterVolume, request, handler, context);
        }
 
        virtual Model::SetLoadBasedAutoScalingOutcome SetLoadBasedAutoScaling(const Model::SetLoadBasedAutoScalingRequest& request) const;
 
        template<typename SetLoadBasedAutoScalingRequestT = Model::SetLoadBasedAutoScalingRequest>
        Model::SetLoadBasedAutoScalingOutcomeCallable SetLoadBasedAutoScalingCallable(const SetLoadBasedAutoScalingRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::SetLoadBasedAutoScaling, request);
        }
 
        template<typename SetLoadBasedAutoScalingRequestT = Model::SetLoadBasedAutoScalingRequest>
        void SetLoadBasedAutoScalingAsync(const SetLoadBasedAutoScalingRequestT& request, const SetLoadBasedAutoScalingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::SetLoadBasedAutoScaling, request, handler, context);
        }
 
        virtual Model::SetPermissionOutcome SetPermission(const Model::SetPermissionRequest& request) const;
 
        template<typename SetPermissionRequestT = Model::SetPermissionRequest>
        Model::SetPermissionOutcomeCallable SetPermissionCallable(const SetPermissionRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::SetPermission, request);
        }
 
        template<typename SetPermissionRequestT = Model::SetPermissionRequest>
        void SetPermissionAsync(const SetPermissionRequestT& request, const SetPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::SetPermission, request, handler, context);
        }
 
        virtual Model::SetTimeBasedAutoScalingOutcome SetTimeBasedAutoScaling(const Model::SetTimeBasedAutoScalingRequest& request) const;
 
        template<typename SetTimeBasedAutoScalingRequestT = Model::SetTimeBasedAutoScalingRequest>
        Model::SetTimeBasedAutoScalingOutcomeCallable SetTimeBasedAutoScalingCallable(const SetTimeBasedAutoScalingRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::SetTimeBasedAutoScaling, request);
        }
 
        template<typename SetTimeBasedAutoScalingRequestT = Model::SetTimeBasedAutoScalingRequest>
        void SetTimeBasedAutoScalingAsync(const SetTimeBasedAutoScalingRequestT& request, const SetTimeBasedAutoScalingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::SetTimeBasedAutoScaling, request, handler, context);
        }
 
        virtual Model::StartInstanceOutcome StartInstance(const Model::StartInstanceRequest& request) const;
 
        template<typename StartInstanceRequestT = Model::StartInstanceRequest>
        Model::StartInstanceOutcomeCallable StartInstanceCallable(const StartInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::StartInstance, request);
        }
 
        template<typename StartInstanceRequestT = Model::StartInstanceRequest>
        void StartInstanceAsync(const StartInstanceRequestT& request, const StartInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::StartInstance, request, handler, context);
        }
 
        virtual Model::StartStackOutcome StartStack(const Model::StartStackRequest& request) const;
 
        template<typename StartStackRequestT = Model::StartStackRequest>
        Model::StartStackOutcomeCallable StartStackCallable(const StartStackRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::StartStack, request);
        }
 
        template<typename StartStackRequestT = Model::StartStackRequest>
        void StartStackAsync(const StartStackRequestT& request, const StartStackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::StartStack, request, handler, context);
        }
 
        virtual Model::StopInstanceOutcome StopInstance(const Model::StopInstanceRequest& request) const;
 
        template<typename StopInstanceRequestT = Model::StopInstanceRequest>
        Model::StopInstanceOutcomeCallable StopInstanceCallable(const StopInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::StopInstance, request);
        }
 
        template<typename StopInstanceRequestT = Model::StopInstanceRequest>
        void StopInstanceAsync(const StopInstanceRequestT& request, const StopInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::StopInstance, request, handler, context);
        }
 
        virtual Model::StopStackOutcome StopStack(const Model::StopStackRequest& request) const;
 
        template<typename StopStackRequestT = Model::StopStackRequest>
        Model::StopStackOutcomeCallable StopStackCallable(const StopStackRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::StopStack, request);
        }
 
        template<typename StopStackRequestT = Model::StopStackRequest>
        void StopStackAsync(const StopStackRequestT& request, const StopStackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::StopStack, 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(&OpsWorksClient::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(&OpsWorksClient::TagResource, request, handler, context);
        }
 
        virtual Model::UnassignInstanceOutcome UnassignInstance(const Model::UnassignInstanceRequest& request) const;
 
        template<typename UnassignInstanceRequestT = Model::UnassignInstanceRequest>
        Model::UnassignInstanceOutcomeCallable UnassignInstanceCallable(const UnassignInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::UnassignInstance, request);
        }
 
        template<typename UnassignInstanceRequestT = Model::UnassignInstanceRequest>
        void UnassignInstanceAsync(const UnassignInstanceRequestT& request, const UnassignInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::UnassignInstance, request, handler, context);
        }
 
        virtual Model::UnassignVolumeOutcome UnassignVolume(const Model::UnassignVolumeRequest& request) const;
 
        template<typename UnassignVolumeRequestT = Model::UnassignVolumeRequest>
        Model::UnassignVolumeOutcomeCallable UnassignVolumeCallable(const UnassignVolumeRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::UnassignVolume, request);
        }
 
        template<typename UnassignVolumeRequestT = Model::UnassignVolumeRequest>
        void UnassignVolumeAsync(const UnassignVolumeRequestT& request, const UnassignVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::UnassignVolume, 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(&OpsWorksClient::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(&OpsWorksClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAppOutcome UpdateApp(const Model::UpdateAppRequest& request) const;
 
        template<typename UpdateAppRequestT = Model::UpdateAppRequest>
        Model::UpdateAppOutcomeCallable UpdateAppCallable(const UpdateAppRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::UpdateApp, request);
        }
 
        template<typename UpdateAppRequestT = Model::UpdateAppRequest>
        void UpdateAppAsync(const UpdateAppRequestT& request, const UpdateAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::UpdateApp, request, handler, context);
        }
 
        virtual Model::UpdateElasticIpOutcome UpdateElasticIp(const Model::UpdateElasticIpRequest& request) const;
 
        template<typename UpdateElasticIpRequestT = Model::UpdateElasticIpRequest>
        Model::UpdateElasticIpOutcomeCallable UpdateElasticIpCallable(const UpdateElasticIpRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::UpdateElasticIp, request);
        }
 
        template<typename UpdateElasticIpRequestT = Model::UpdateElasticIpRequest>
        void UpdateElasticIpAsync(const UpdateElasticIpRequestT& request, const UpdateElasticIpResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::UpdateElasticIp, request, handler, context);
        }
 
        virtual Model::UpdateInstanceOutcome UpdateInstance(const Model::UpdateInstanceRequest& request) const;
 
        template<typename UpdateInstanceRequestT = Model::UpdateInstanceRequest>
        Model::UpdateInstanceOutcomeCallable UpdateInstanceCallable(const UpdateInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::UpdateInstance, request);
        }
 
        template<typename UpdateInstanceRequestT = Model::UpdateInstanceRequest>
        void UpdateInstanceAsync(const UpdateInstanceRequestT& request, const UpdateInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::UpdateInstance, request, handler, context);
        }
 
        virtual Model::UpdateLayerOutcome UpdateLayer(const Model::UpdateLayerRequest& request) const;
 
        template<typename UpdateLayerRequestT = Model::UpdateLayerRequest>
        Model::UpdateLayerOutcomeCallable UpdateLayerCallable(const UpdateLayerRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::UpdateLayer, request);
        }
 
        template<typename UpdateLayerRequestT = Model::UpdateLayerRequest>
        void UpdateLayerAsync(const UpdateLayerRequestT& request, const UpdateLayerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::UpdateLayer, request, handler, context);
        }
 
        virtual Model::UpdateMyUserProfileOutcome UpdateMyUserProfile(const Model::UpdateMyUserProfileRequest& request = {}) const;
 
        template<typename UpdateMyUserProfileRequestT = Model::UpdateMyUserProfileRequest>
        Model::UpdateMyUserProfileOutcomeCallable UpdateMyUserProfileCallable(const UpdateMyUserProfileRequestT& request = {}) const
        {
            return SubmitCallable(&OpsWorksClient::UpdateMyUserProfile, request);
        }
 
        template<typename UpdateMyUserProfileRequestT = Model::UpdateMyUserProfileRequest>
        void UpdateMyUserProfileAsync(const UpdateMyUserProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateMyUserProfileRequestT& request = {}) const
        {
            return SubmitAsync(&OpsWorksClient::UpdateMyUserProfile, request, handler, context);
        }
 
        virtual Model::UpdateRdsDbInstanceOutcome UpdateRdsDbInstance(const Model::UpdateRdsDbInstanceRequest& request) const;
 
        template<typename UpdateRdsDbInstanceRequestT = Model::UpdateRdsDbInstanceRequest>
        Model::UpdateRdsDbInstanceOutcomeCallable UpdateRdsDbInstanceCallable(const UpdateRdsDbInstanceRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::UpdateRdsDbInstance, request);
        }
 
        template<typename UpdateRdsDbInstanceRequestT = Model::UpdateRdsDbInstanceRequest>
        void UpdateRdsDbInstanceAsync(const UpdateRdsDbInstanceRequestT& request, const UpdateRdsDbInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::UpdateRdsDbInstance, 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(&OpsWorksClient::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(&OpsWorksClient::UpdateStack, request, handler, context);
        }
 
        virtual Model::UpdateUserProfileOutcome UpdateUserProfile(const Model::UpdateUserProfileRequest& request) const;
 
        template<typename UpdateUserProfileRequestT = Model::UpdateUserProfileRequest>
        Model::UpdateUserProfileOutcomeCallable UpdateUserProfileCallable(const UpdateUserProfileRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::UpdateUserProfile, request);
        }
 
        template<typename UpdateUserProfileRequestT = Model::UpdateUserProfileRequest>
        void UpdateUserProfileAsync(const UpdateUserProfileRequestT& request, const UpdateUserProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::UpdateUserProfile, request, handler, context);
        }
 
        virtual Model::UpdateVolumeOutcome UpdateVolume(const Model::UpdateVolumeRequest& request) const;
 
        template<typename UpdateVolumeRequestT = Model::UpdateVolumeRequest>
        Model::UpdateVolumeOutcomeCallable UpdateVolumeCallable(const UpdateVolumeRequestT& request) const
        {
            return SubmitCallable(&OpsWorksClient::UpdateVolume, request);
        }
 
        template<typename UpdateVolumeRequestT = Model::UpdateVolumeRequest>
        void UpdateVolumeAsync(const UpdateVolumeRequestT& request, const UpdateVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OpsWorksClient::UpdateVolume, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<OpsWorksEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<OpsWorksClient>;
      void init(const OpsWorksClientConfiguration& clientConfiguration);
 
      OpsWorksClientConfiguration m_clientConfiguration;
      std::shared_ptr<OpsWorksEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace OpsWorks
} // namespace Aws