/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace OpsWorks { /** * AWS OpsWorks

Welcome to the AWS OpsWorks Stacks API * Reference. This guide provides descriptions, syntax, and usage examples for * AWS OpsWorks Stacks actions and data types, including common parameters and * error codes.

AWS OpsWorks Stacks is an application management service * that provides an integrated experience for overseeing the complete application * lifecycle. For information about this product, go to the AWS OpsWorks details page.

* SDKs and CLI

The most common way to use the AWS OpsWorks Stacks * API is by using the AWS Command Line Interface (CLI) or by using one of the AWS * SDKs to implement applications in your preferred language. For more information, * see:

Endpoints

AWS OpsWorks * Stacks supports the following endpoints, all HTTPS. You must connect to one of * the following endpoints. Stacks can only be accessed or managed within the * endpoint in which they are created.

  • *

    opsworks.us-east-1.amazonaws.com

  • *

    opsworks.us-east-2.amazonaws.com

  • *

    opsworks.us-west-1.amazonaws.com

  • *

    opsworks.us-west-2.amazonaws.com

  • *

    opsworks.ca-central-1.amazonaws.com (API only; not available in the AWS * console)

  • opsworks.eu-west-1.amazonaws.com

  • *

    opsworks.eu-west-2.amazonaws.com

  • *

    opsworks.eu-west-3.amazonaws.com

  • *

    opsworks.eu-central-1.amazonaws.com

  • *

    opsworks.ap-northeast-1.amazonaws.com

  • *

    opsworks.ap-northeast-2.amazonaws.com

  • *

    opsworks.ap-south-1.amazonaws.com

  • *

    opsworks.ap-southeast-1.amazonaws.com

  • *

    opsworks.ap-southeast-2.amazonaws.com

  • *

    opsworks.sa-east-1.amazonaws.com

Chef Versions *

When you call CreateStack, CloneStack, or * UpdateStack we recommend you use the ConfigurationManager * parameter to specify the Chef version. The recommended and default value for * Linux stacks is currently 12. Windows stacks use Chef 12.2. For more * information, see Chef * Versions.

You can specify Chef 12, 11.10, or 11.4 for your * Linux stack. We recommend migrating your existing Linux stacks to Chef 12 as * soon as possible.

*/ class AWS_OPSWORKS_API OpsWorksClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef OpsWorksClientConfiguration ClientConfigurationType; typedef OpsWorksEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ OpsWorksClient(const Aws::OpsWorks::OpsWorksClientConfiguration& clientConfiguration = Aws::OpsWorks::OpsWorksClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ OpsWorksClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::OpsWorks::OpsWorksClientConfiguration& clientConfiguration = Aws::OpsWorks::OpsWorksClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ OpsWorksClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::OpsWorks::OpsWorksClientConfiguration& clientConfiguration = Aws::OpsWorks::OpsWorksClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ OpsWorksClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ OpsWorksClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ OpsWorksClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~OpsWorksClient(); /** *

Assign a registered instance to a layer.

  • You can assign * registered on-premises instances to any layer type.

  • You can * assign registered Amazon EC2 instances only to custom layers.

  • *

    You cannot use this action with instances that were created with AWS OpsWorks * Stacks.

Required Permissions: To use this action, an * AWS Identity and Access Management (IAM) user must have a Manage permissions * level for the stack or an attached policy that explicitly grants permissions. * For more information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::AssignInstanceOutcome AssignInstance(const Model::AssignInstanceRequest& request) const; /** * A Callable wrapper for AssignInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssignInstanceOutcomeCallable AssignInstanceCallable(const AssignInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::AssignInstance, request); } /** * An Async wrapper for AssignInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssignInstanceAsync(const AssignInstanceRequestT& request, const AssignInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::AssignInstance, request, handler, context); } /** *

Assigns one of the stack's registered Amazon EBS volumes to a specified * instance. The volume must first be registered with the stack by calling * RegisterVolume. After you register the volume, you must call * UpdateVolume to specify a mount point before calling * AssignVolume. For more information, see Resource * Management.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::AssignVolumeOutcome AssignVolume(const Model::AssignVolumeRequest& request) const; /** * A Callable wrapper for AssignVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssignVolumeOutcomeCallable AssignVolumeCallable(const AssignVolumeRequestT& request) const { return SubmitCallable(&OpsWorksClient::AssignVolume, request); } /** * An Async wrapper for AssignVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssignVolumeAsync(const AssignVolumeRequestT& request, const AssignVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::AssignVolume, request, handler, context); } /** *

Associates one of the stack's registered Elastic IP addresses with a * specified instance. The address must first be registered with the stack by * calling RegisterElasticIp. For more information, see Resource * Management.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::AssociateElasticIpOutcome AssociateElasticIp(const Model::AssociateElasticIpRequest& request) const; /** * A Callable wrapper for AssociateElasticIp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateElasticIpOutcomeCallable AssociateElasticIpCallable(const AssociateElasticIpRequestT& request) const { return SubmitCallable(&OpsWorksClient::AssociateElasticIp, request); } /** * An Async wrapper for AssociateElasticIp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateElasticIpAsync(const AssociateElasticIpRequestT& request, const AssociateElasticIpResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::AssociateElasticIp, request, handler, context); } /** *

Attaches an Elastic Load Balancing load balancer to a specified layer. AWS * OpsWorks Stacks does not support Application Load Balancer. You can only use * Classic Load Balancer with AWS OpsWorks Stacks. For more information, see Elastic * Load Balancing.

You must create the Elastic Load Balancing * instance separately, by using the Elastic Load Balancing console, API, or CLI. * For more information, see * Elastic Load Balancing Developer Guide.

Required * Permissions: To use this action, an IAM user must have a Manage permissions * level for the stack, or an attached policy that explicitly grants permissions. * For more information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::AttachElasticLoadBalancerOutcome AttachElasticLoadBalancer(const Model::AttachElasticLoadBalancerRequest& request) const; /** * A Callable wrapper for AttachElasticLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachElasticLoadBalancerOutcomeCallable AttachElasticLoadBalancerCallable(const AttachElasticLoadBalancerRequestT& request) const { return SubmitCallable(&OpsWorksClient::AttachElasticLoadBalancer, request); } /** * An Async wrapper for AttachElasticLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachElasticLoadBalancerAsync(const AttachElasticLoadBalancerRequestT& request, const AttachElasticLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::AttachElasticLoadBalancer, request, handler, context); } /** *

Creates a clone of a specified stack. For more information, see Clone * a Stack. By default, all parameters are set to the values used by the parent * stack.

Required Permissions: To use this action, an IAM user must * have an attached policy that explicitly grants permissions. For more information * about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::CloneStackOutcome CloneStack(const Model::CloneStackRequest& request) const; /** * A Callable wrapper for CloneStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CloneStackOutcomeCallable CloneStackCallable(const CloneStackRequestT& request) const { return SubmitCallable(&OpsWorksClient::CloneStack, request); } /** * An Async wrapper for CloneStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CloneStackAsync(const CloneStackRequestT& request, const CloneStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::CloneStack, request, handler, context); } /** *

Creates an app for a specified stack. For more information, see Creating * Apps.

Required Permissions: To use this action, an IAM user * must have a Manage permissions level for the stack, or an attached policy that * explicitly grants permissions. For more information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::CreateAppOutcome CreateApp(const Model::CreateAppRequest& request) const; /** * A Callable wrapper for CreateApp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAppOutcomeCallable CreateAppCallable(const CreateAppRequestT& request) const { return SubmitCallable(&OpsWorksClient::CreateApp, request); } /** * An Async wrapper for CreateApp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAppAsync(const CreateAppRequestT& request, const CreateAppResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::CreateApp, request, handler, context); } /** *

Runs deployment or stack commands. For more information, see Deploying * Apps and Run * Stack Commands.

Required Permissions: To use this action, an * IAM user must have a Deploy or Manage permissions level for the stack, or an * attached policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::CreateDeploymentOutcome CreateDeployment(const Model::CreateDeploymentRequest& request) const; /** * A Callable wrapper for CreateDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDeploymentOutcomeCallable CreateDeploymentCallable(const CreateDeploymentRequestT& request) const { return SubmitCallable(&OpsWorksClient::CreateDeployment, request); } /** * An Async wrapper for CreateDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDeploymentAsync(const CreateDeploymentRequestT& request, const CreateDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::CreateDeployment, request, handler, context); } /** *

Creates an instance in a specified stack. For more information, see Adding * an Instance to a Layer.

Required Permissions: To use this * action, an IAM user must have a Manage permissions level for the stack, or an * attached policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::CreateInstanceOutcome CreateInstance(const Model::CreateInstanceRequest& request) const; /** * A Callable wrapper for CreateInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInstanceOutcomeCallable CreateInstanceCallable(const CreateInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::CreateInstance, request); } /** * An Async wrapper for CreateInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInstanceAsync(const CreateInstanceRequestT& request, const CreateInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::CreateInstance, request, handler, context); } /** *

Creates a layer. For more information, see How * to Create a Layer.

You should use CreateLayer for * noncustom layer types such as PHP App Server only if the stack does not have an * existing layer of that type. A stack can have at most one instance of each * noncustom layer; if you attempt to create a second instance, CreateLayer * fails. A stack can have an arbitrary number of custom layers, so you can call * CreateLayer as many times as you like for that layer type.

*

Required Permissions: To use this action, an IAM user must have a * Manage permissions level for the stack, or an attached policy that explicitly * grants permissions. For more information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::CreateLayerOutcome CreateLayer(const Model::CreateLayerRequest& request) const; /** * A Callable wrapper for CreateLayer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLayerOutcomeCallable CreateLayerCallable(const CreateLayerRequestT& request) const { return SubmitCallable(&OpsWorksClient::CreateLayer, request); } /** * An Async wrapper for CreateLayer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLayerAsync(const CreateLayerRequestT& request, const CreateLayerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::CreateLayer, request, handler, context); } /** *

Creates a new stack. For more information, see Create * a New Stack.

Required Permissions: To use this action, an IAM * user must have an attached policy that explicitly grants permissions. For more * information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::CreateStackOutcome CreateStack(const Model::CreateStackRequest& request) const; /** * A Callable wrapper for CreateStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStackOutcomeCallable CreateStackCallable(const CreateStackRequestT& request) const { return SubmitCallable(&OpsWorksClient::CreateStack, request); } /** * An Async wrapper for CreateStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStackAsync(const CreateStackRequestT& request, const CreateStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::CreateStack, request, handler, context); } /** *

Creates a new user profile.

Required Permissions: To use this * action, an IAM user must have an attached policy that explicitly grants * permissions. For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::CreateUserProfileOutcome CreateUserProfile(const Model::CreateUserProfileRequest& request) const; /** * A Callable wrapper for CreateUserProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUserProfileOutcomeCallable CreateUserProfileCallable(const CreateUserProfileRequestT& request) const { return SubmitCallable(&OpsWorksClient::CreateUserProfile, request); } /** * An Async wrapper for CreateUserProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUserProfileAsync(const CreateUserProfileRequestT& request, const CreateUserProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::CreateUserProfile, request, handler, context); } /** *

Deletes a specified app.

Required Permissions: To use this * action, an IAM user must have a Manage permissions level for the stack, or an * attached policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAppOutcome DeleteApp(const Model::DeleteAppRequest& request) const; /** * A Callable wrapper for DeleteApp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAppOutcomeCallable DeleteAppCallable(const DeleteAppRequestT& request) const { return SubmitCallable(&OpsWorksClient::DeleteApp, request); } /** * An Async wrapper for DeleteApp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAppAsync(const DeleteAppRequestT& request, const DeleteAppResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DeleteApp, request, handler, context); } /** *

Deletes a specified instance, which terminates the associated Amazon EC2 * instance. You must stop an instance before you can delete it.

For more * information, see Deleting * Instances.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DeleteInstanceOutcome DeleteInstance(const Model::DeleteInstanceRequest& request) const; /** * A Callable wrapper for DeleteInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInstanceOutcomeCallable DeleteInstanceCallable(const DeleteInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::DeleteInstance, request); } /** * An Async wrapper for DeleteInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInstanceAsync(const DeleteInstanceRequestT& request, const DeleteInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DeleteInstance, request, handler, context); } /** *

Deletes a specified layer. You must first stop and then delete all associated * instances or unassign registered instances. For more information, see How * to Delete a Layer.

Required Permissions: To use this action, * an IAM user must have a Manage permissions level for the stack, or an attached * policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLayerOutcome DeleteLayer(const Model::DeleteLayerRequest& request) const; /** * A Callable wrapper for DeleteLayer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLayerOutcomeCallable DeleteLayerCallable(const DeleteLayerRequestT& request) const { return SubmitCallable(&OpsWorksClient::DeleteLayer, request); } /** * An Async wrapper for DeleteLayer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLayerAsync(const DeleteLayerRequestT& request, const DeleteLayerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DeleteLayer, request, handler, context); } /** *

Deletes a specified stack. You must first delete all instances, layers, and * apps or deregister registered instances. For more information, see Shut * Down a Stack.

Required Permissions: To use this action, an * IAM user must have a Manage permissions level for the stack, or an attached * policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStackOutcome DeleteStack(const Model::DeleteStackRequest& request) const; /** * A Callable wrapper for DeleteStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStackOutcomeCallable DeleteStackCallable(const DeleteStackRequestT& request) const { return SubmitCallable(&OpsWorksClient::DeleteStack, request); } /** * An Async wrapper for DeleteStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStackAsync(const DeleteStackRequestT& request, const DeleteStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DeleteStack, request, handler, context); } /** *

Deletes a user profile.

Required Permissions: To use this * action, an IAM user must have an attached policy that explicitly grants * permissions. For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DeleteUserProfileOutcome DeleteUserProfile(const Model::DeleteUserProfileRequest& request) const; /** * A Callable wrapper for DeleteUserProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteUserProfileOutcomeCallable DeleteUserProfileCallable(const DeleteUserProfileRequestT& request) const { return SubmitCallable(&OpsWorksClient::DeleteUserProfile, request); } /** * An Async wrapper for DeleteUserProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteUserProfileAsync(const DeleteUserProfileRequestT& request, const DeleteUserProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DeleteUserProfile, request, handler, context); } /** *

Deregisters a specified Amazon ECS cluster from a stack. For more * information, see * Resource Management.

Required Permissions: To use this * action, an IAM user must have a Manage permissions level for the stack or an * attached policy that explicitly grants permissions. For more information on user * permissions, see https://docs.aws.amazon.com/opsworks/latest/userguide/opsworks-security-users.html.

See * Also:

AWS * API Reference

*/ virtual Model::DeregisterEcsClusterOutcome DeregisterEcsCluster(const Model::DeregisterEcsClusterRequest& request) const; /** * A Callable wrapper for DeregisterEcsCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterEcsClusterOutcomeCallable DeregisterEcsClusterCallable(const DeregisterEcsClusterRequestT& request) const { return SubmitCallable(&OpsWorksClient::DeregisterEcsCluster, request); } /** * An Async wrapper for DeregisterEcsCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterEcsClusterAsync(const DeregisterEcsClusterRequestT& request, const DeregisterEcsClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DeregisterEcsCluster, request, handler, context); } /** *

Deregisters a specified Elastic IP address. The address can then be * registered by another stack. For more information, see Resource * Management.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterElasticIpOutcome DeregisterElasticIp(const Model::DeregisterElasticIpRequest& request) const; /** * A Callable wrapper for DeregisterElasticIp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterElasticIpOutcomeCallable DeregisterElasticIpCallable(const DeregisterElasticIpRequestT& request) const { return SubmitCallable(&OpsWorksClient::DeregisterElasticIp, request); } /** * An Async wrapper for DeregisterElasticIp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterElasticIpAsync(const DeregisterElasticIpRequestT& request, const DeregisterElasticIpResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DeregisterElasticIp, request, handler, context); } /** *

Deregister a registered Amazon EC2 or on-premises instance. This action * removes the instance from the stack and returns it to your control. This action * cannot be used with instances that were created with AWS OpsWorks Stacks.

*

Required Permissions: To use this action, an IAM user must have a * Manage permissions level for the stack or an attached policy that explicitly * grants permissions. For more information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterInstanceOutcome DeregisterInstance(const Model::DeregisterInstanceRequest& request) const; /** * A Callable wrapper for DeregisterInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterInstanceOutcomeCallable DeregisterInstanceCallable(const DeregisterInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::DeregisterInstance, request); } /** * An Async wrapper for DeregisterInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterInstanceAsync(const DeregisterInstanceRequestT& request, const DeregisterInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DeregisterInstance, request, handler, context); } /** *

Deregisters an Amazon RDS instance.

Required Permissions: To * use this action, an IAM user must have a Manage permissions level for the stack, * or an attached policy that explicitly grants permissions. For more information * on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterRdsDbInstanceOutcome DeregisterRdsDbInstance(const Model::DeregisterRdsDbInstanceRequest& request) const; /** * A Callable wrapper for DeregisterRdsDbInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterRdsDbInstanceOutcomeCallable DeregisterRdsDbInstanceCallable(const DeregisterRdsDbInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::DeregisterRdsDbInstance, request); } /** * An Async wrapper for DeregisterRdsDbInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterRdsDbInstanceAsync(const DeregisterRdsDbInstanceRequestT& request, const DeregisterRdsDbInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DeregisterRdsDbInstance, request, handler, context); } /** *

Deregisters an Amazon EBS volume. The volume can then be registered by * another stack. For more information, see Resource * Management.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterVolumeOutcome DeregisterVolume(const Model::DeregisterVolumeRequest& request) const; /** * A Callable wrapper for DeregisterVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterVolumeOutcomeCallable DeregisterVolumeCallable(const DeregisterVolumeRequestT& request) const { return SubmitCallable(&OpsWorksClient::DeregisterVolume, request); } /** * An Async wrapper for DeregisterVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterVolumeAsync(const DeregisterVolumeRequestT& request, const DeregisterVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DeregisterVolume, request, handler, context); } /** *

Describes the available AWS OpsWorks Stacks agent versions. You must specify * a stack ID or a configuration manager. DescribeAgentVersions * returns a list of available agent versions for the specified stack or * configuration manager.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAgentVersionsOutcome DescribeAgentVersions(const Model::DescribeAgentVersionsRequest& request) const; /** * A Callable wrapper for DescribeAgentVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAgentVersionsOutcomeCallable DescribeAgentVersionsCallable(const DescribeAgentVersionsRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeAgentVersions, request); } /** * An Async wrapper for DescribeAgentVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAgentVersionsAsync(const DescribeAgentVersionsRequestT& request, const DescribeAgentVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeAgentVersions, request, handler, context); } /** *

Requests a description of a specified set of apps.

This call * accepts only one resource-identifying parameter.

Required * Permissions: To use this action, an IAM user must have a Show, Deploy, or * Manage permissions level for the stack, or an attached policy that explicitly * grants permissions. For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAppsOutcome DescribeApps(const Model::DescribeAppsRequest& request) const; /** * A Callable wrapper for DescribeApps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAppsOutcomeCallable DescribeAppsCallable(const DescribeAppsRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeApps, request); } /** * An Async wrapper for DescribeApps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAppsAsync(const DescribeAppsRequestT& request, const DescribeAppsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeApps, request, handler, context); } /** *

Describes the results of specified commands.

This call accepts * only one resource-identifying parameter.

Required * Permissions: To use this action, an IAM user must have a Show, Deploy, or * Manage permissions level for the stack, or an attached policy that explicitly * grants permissions. For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCommandsOutcome DescribeCommands(const Model::DescribeCommandsRequest& request) const; /** * A Callable wrapper for DescribeCommands that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCommandsOutcomeCallable DescribeCommandsCallable(const DescribeCommandsRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeCommands, request); } /** * An Async wrapper for DescribeCommands that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCommandsAsync(const DescribeCommandsRequestT& request, const DescribeCommandsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeCommands, request, handler, context); } /** *

Requests a description of a specified set of deployments.

This * call accepts only one resource-identifying parameter.

* Required Permissions: To use this action, an IAM user must have a Show, * Deploy, or Manage permissions level for the stack, or an attached policy that * explicitly grants permissions. For more information about user permissions, see * Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDeploymentsOutcome DescribeDeployments(const Model::DescribeDeploymentsRequest& request) const; /** * A Callable wrapper for DescribeDeployments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDeploymentsOutcomeCallable DescribeDeploymentsCallable(const DescribeDeploymentsRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeDeployments, request); } /** * An Async wrapper for DescribeDeployments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDeploymentsAsync(const DescribeDeploymentsRequestT& request, const DescribeDeploymentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeDeployments, request, handler, context); } /** *

Describes Amazon ECS clusters that are registered with a stack. If you * specify only a stack ID, you can use the MaxResults and * NextToken parameters to paginate the response. However, AWS * OpsWorks Stacks currently supports only one cluster per layer, so the result set * has a maximum of one element.

Required Permissions: To use this * action, an IAM user must have a Show, Deploy, or Manage permissions level for * the stack or an attached policy that explicitly grants permission. For more * information about user permissions, see Managing * User Permissions.

This call accepts only one resource-identifying * parameter.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEcsClustersOutcome DescribeEcsClusters(const Model::DescribeEcsClustersRequest& request) const; /** * A Callable wrapper for DescribeEcsClusters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEcsClustersOutcomeCallable DescribeEcsClustersCallable(const DescribeEcsClustersRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeEcsClusters, request); } /** * An Async wrapper for DescribeEcsClusters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEcsClustersAsync(const DescribeEcsClustersRequestT& request, const DescribeEcsClustersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeEcsClusters, request, handler, context); } /** *

Describes Elastic * IP addresses.

This call accepts only one resource-identifying * parameter.

Required Permissions: To use this action, an * IAM user must have a Show, Deploy, or Manage permissions level for the stack, or * an attached policy that explicitly grants permissions. For more information * about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeElasticIpsOutcome DescribeElasticIps(const Model::DescribeElasticIpsRequest& request) const; /** * A Callable wrapper for DescribeElasticIps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeElasticIpsOutcomeCallable DescribeElasticIpsCallable(const DescribeElasticIpsRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeElasticIps, request); } /** * An Async wrapper for DescribeElasticIps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeElasticIpsAsync(const DescribeElasticIpsRequestT& request, const DescribeElasticIpsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeElasticIps, request, handler, context); } /** *

Describes a stack's Elastic Load Balancing instances.

This call * accepts only one resource-identifying parameter.

Required * Permissions: To use this action, an IAM user must have a Show, Deploy, or * Manage permissions level for the stack, or an attached policy that explicitly * grants permissions. For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeElasticLoadBalancersOutcome DescribeElasticLoadBalancers(const Model::DescribeElasticLoadBalancersRequest& request) const; /** * A Callable wrapper for DescribeElasticLoadBalancers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeElasticLoadBalancersOutcomeCallable DescribeElasticLoadBalancersCallable(const DescribeElasticLoadBalancersRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeElasticLoadBalancers, request); } /** * An Async wrapper for DescribeElasticLoadBalancers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeElasticLoadBalancersAsync(const DescribeElasticLoadBalancersRequestT& request, const DescribeElasticLoadBalancersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeElasticLoadBalancers, request, handler, context); } /** *

Requests a description of a set of instances.

This call accepts * only one resource-identifying parameter.

Required * Permissions: To use this action, an IAM user must have a Show, Deploy, or * Manage permissions level for the stack, or an attached policy that explicitly * grants permissions. For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstancesOutcome DescribeInstances(const Model::DescribeInstancesRequest& request) const; /** * A Callable wrapper for DescribeInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstancesOutcomeCallable DescribeInstancesCallable(const DescribeInstancesRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeInstances, request); } /** * An Async wrapper for DescribeInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstancesAsync(const DescribeInstancesRequestT& request, const DescribeInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeInstances, request, handler, context); } /** *

Requests a description of one or more layers in a specified stack.

*

This call accepts only one resource-identifying parameter.

* Required Permissions: To use this action, an IAM user must have a Show, * Deploy, or Manage permissions level for the stack, or an attached policy that * explicitly grants permissions. For more information about user permissions, see * Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLayersOutcome DescribeLayers(const Model::DescribeLayersRequest& request) const; /** * A Callable wrapper for DescribeLayers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLayersOutcomeCallable DescribeLayersCallable(const DescribeLayersRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeLayers, request); } /** * An Async wrapper for DescribeLayers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLayersAsync(const DescribeLayersRequestT& request, const DescribeLayersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeLayers, request, handler, context); } /** *

Describes load-based auto scaling configurations for specified layers.

*

You must specify at least one of the parameters.

* Required Permissions: To use this action, an IAM user must have a Show, * Deploy, or Manage permissions level for the stack, or an attached policy that * explicitly grants permissions. For more information about user permissions, see * Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLoadBasedAutoScalingOutcome DescribeLoadBasedAutoScaling(const Model::DescribeLoadBasedAutoScalingRequest& request) const; /** * A Callable wrapper for DescribeLoadBasedAutoScaling that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLoadBasedAutoScalingOutcomeCallable DescribeLoadBasedAutoScalingCallable(const DescribeLoadBasedAutoScalingRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeLoadBasedAutoScaling, request); } /** * An Async wrapper for DescribeLoadBasedAutoScaling that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLoadBasedAutoScalingAsync(const DescribeLoadBasedAutoScalingRequestT& request, const DescribeLoadBasedAutoScalingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeLoadBasedAutoScaling, request, handler, context); } /** *

Describes a user's SSH information.

Required Permissions: To * use this action, an IAM user must have self-management enabled or an attached * policy that explicitly grants permissions. For more information about user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMyUserProfileOutcome DescribeMyUserProfile() const; /** * A Callable wrapper for DescribeMyUserProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMyUserProfileOutcomeCallable DescribeMyUserProfileCallable() const { return SubmitCallable(&OpsWorksClient::DescribeMyUserProfile); } /** * An Async wrapper for DescribeMyUserProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMyUserProfileAsync(const DescribeMyUserProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeMyUserProfile, handler, context); } /** *

Describes the operating systems that are supported by AWS OpsWorks * Stacks.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOperatingSystemsOutcome DescribeOperatingSystems() const; /** * A Callable wrapper for DescribeOperatingSystems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOperatingSystemsOutcomeCallable DescribeOperatingSystemsCallable() const { return SubmitCallable(&OpsWorksClient::DescribeOperatingSystems); } /** * An Async wrapper for DescribeOperatingSystems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOperatingSystemsAsync(const DescribeOperatingSystemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeOperatingSystems, handler, context); } /** *

Describes the permissions for a specified stack.

Required * Permissions: To use this action, an IAM user must have a Manage permissions * level for the stack, or an attached policy that explicitly grants permissions. * For more information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribePermissionsOutcome DescribePermissions(const Model::DescribePermissionsRequest& request) const; /** * A Callable wrapper for DescribePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePermissionsOutcomeCallable DescribePermissionsCallable(const DescribePermissionsRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribePermissions, request); } /** * An Async wrapper for DescribePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePermissionsAsync(const DescribePermissionsRequestT& request, const DescribePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribePermissions, request, handler, context); } /** *

Describe an instance's RAID arrays.

This call accepts only one * resource-identifying parameter.

Required Permissions: To * use this action, an IAM user must have a Show, Deploy, or Manage permissions * level for the stack, or an attached policy that explicitly grants permissions. * For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeRaidArraysOutcome DescribeRaidArrays(const Model::DescribeRaidArraysRequest& request) const; /** * A Callable wrapper for DescribeRaidArrays that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRaidArraysOutcomeCallable DescribeRaidArraysCallable(const DescribeRaidArraysRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeRaidArrays, request); } /** * An Async wrapper for DescribeRaidArrays that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRaidArraysAsync(const DescribeRaidArraysRequestT& request, const DescribeRaidArraysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeRaidArrays, request, handler, context); } /** *

Describes Amazon RDS instances.

Required Permissions: To use * this action, an IAM user must have a Show, Deploy, or Manage permissions level * for the stack, or an attached policy that explicitly grants permissions. For * more information about user permissions, see Managing * User Permissions.

This call accepts only one resource-identifying * parameter.

See Also:

AWS * API Reference

*/ virtual Model::DescribeRdsDbInstancesOutcome DescribeRdsDbInstances(const Model::DescribeRdsDbInstancesRequest& request) const; /** * A Callable wrapper for DescribeRdsDbInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRdsDbInstancesOutcomeCallable DescribeRdsDbInstancesCallable(const DescribeRdsDbInstancesRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeRdsDbInstances, request); } /** * An Async wrapper for DescribeRdsDbInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRdsDbInstancesAsync(const DescribeRdsDbInstancesRequestT& request, const DescribeRdsDbInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeRdsDbInstances, request, handler, context); } /** *

Describes AWS OpsWorks Stacks service errors.

Required * Permissions: To use this action, an IAM user must have a Show, Deploy, or * Manage permissions level for the stack, or an attached policy that explicitly * grants permissions. For more information about user permissions, see Managing * User Permissions.

This call accepts only one resource-identifying * parameter.

See Also:

AWS * API Reference

*/ virtual Model::DescribeServiceErrorsOutcome DescribeServiceErrors(const Model::DescribeServiceErrorsRequest& request) const; /** * A Callable wrapper for DescribeServiceErrors that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeServiceErrorsOutcomeCallable DescribeServiceErrorsCallable(const DescribeServiceErrorsRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeServiceErrors, request); } /** * An Async wrapper for DescribeServiceErrors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeServiceErrorsAsync(const DescribeServiceErrorsRequestT& request, const DescribeServiceErrorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeServiceErrors, request, handler, context); } /** *

Requests a description of a stack's provisioning parameters.

* Required Permissions: To use this action, an IAM user must have a Show, * Deploy, or Manage permissions level for the stack or an attached policy that * explicitly grants permissions. For more information about user permissions, see * Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStackProvisioningParametersOutcome DescribeStackProvisioningParameters(const Model::DescribeStackProvisioningParametersRequest& request) const; /** * A Callable wrapper for DescribeStackProvisioningParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStackProvisioningParametersOutcomeCallable DescribeStackProvisioningParametersCallable(const DescribeStackProvisioningParametersRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeStackProvisioningParameters, request); } /** * An Async wrapper for DescribeStackProvisioningParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStackProvisioningParametersAsync(const DescribeStackProvisioningParametersRequestT& request, const DescribeStackProvisioningParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeStackProvisioningParameters, request, handler, context); } /** *

Describes the number of layers and apps in a specified stack, and the number * of instances in each state, such as running_setup or * online.

Required Permissions: To use this action, an * IAM user must have a Show, Deploy, or Manage permissions level for the stack, or * an attached policy that explicitly grants permissions. For more information * about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStackSummaryOutcome DescribeStackSummary(const Model::DescribeStackSummaryRequest& request) const; /** * A Callable wrapper for DescribeStackSummary that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStackSummaryOutcomeCallable DescribeStackSummaryCallable(const DescribeStackSummaryRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeStackSummary, request); } /** * An Async wrapper for DescribeStackSummary that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStackSummaryAsync(const DescribeStackSummaryRequestT& request, const DescribeStackSummaryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeStackSummary, request, handler, context); } /** *

Requests a description of one or more stacks.

Required * Permissions: To use this action, an IAM user must have a Show, Deploy, or * Manage permissions level for the stack, or an attached policy that explicitly * grants permissions. For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStacksOutcome DescribeStacks(const Model::DescribeStacksRequest& request) const; /** * A Callable wrapper for DescribeStacks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStacksOutcomeCallable DescribeStacksCallable(const DescribeStacksRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeStacks, request); } /** * An Async wrapper for DescribeStacks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStacksAsync(const DescribeStacksRequestT& request, const DescribeStacksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeStacks, request, handler, context); } /** *

Describes time-based auto scaling configurations for specified instances.

*

You must specify at least one of the parameters.

* Required Permissions: To use this action, an IAM user must have a Show, * Deploy, or Manage permissions level for the stack, or an attached policy that * explicitly grants permissions. For more information about user permissions, see * Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTimeBasedAutoScalingOutcome DescribeTimeBasedAutoScaling(const Model::DescribeTimeBasedAutoScalingRequest& request) const; /** * A Callable wrapper for DescribeTimeBasedAutoScaling that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTimeBasedAutoScalingOutcomeCallable DescribeTimeBasedAutoScalingCallable(const DescribeTimeBasedAutoScalingRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeTimeBasedAutoScaling, request); } /** * An Async wrapper for DescribeTimeBasedAutoScaling that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTimeBasedAutoScalingAsync(const DescribeTimeBasedAutoScalingRequestT& request, const DescribeTimeBasedAutoScalingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeTimeBasedAutoScaling, request, handler, context); } /** *

Describe specified users.

Required Permissions: To use this * action, an IAM user must have an attached policy that explicitly grants * permissions. For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeUserProfilesOutcome DescribeUserProfiles(const Model::DescribeUserProfilesRequest& request) const; /** * A Callable wrapper for DescribeUserProfiles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeUserProfilesOutcomeCallable DescribeUserProfilesCallable(const DescribeUserProfilesRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeUserProfiles, request); } /** * An Async wrapper for DescribeUserProfiles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeUserProfilesAsync(const DescribeUserProfilesRequestT& request, const DescribeUserProfilesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeUserProfiles, request, handler, context); } /** *

Describes an instance's Amazon EBS volumes.

This call accepts * only one resource-identifying parameter.

Required * Permissions: To use this action, an IAM user must have a Show, Deploy, or * Manage permissions level for the stack, or an attached policy that explicitly * grants permissions. For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVolumesOutcome DescribeVolumes(const Model::DescribeVolumesRequest& request) const; /** * A Callable wrapper for DescribeVolumes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVolumesOutcomeCallable DescribeVolumesCallable(const DescribeVolumesRequestT& request) const { return SubmitCallable(&OpsWorksClient::DescribeVolumes, request); } /** * An Async wrapper for DescribeVolumes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVolumesAsync(const DescribeVolumesRequestT& request, const DescribeVolumesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DescribeVolumes, request, handler, context); } /** *

Detaches a specified Elastic Load Balancing instance from its layer.

* Required Permissions: To use this action, an IAM user must have a Manage * permissions level for the stack, or an attached policy that explicitly grants * permissions. For more information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DetachElasticLoadBalancerOutcome DetachElasticLoadBalancer(const Model::DetachElasticLoadBalancerRequest& request) const; /** * A Callable wrapper for DetachElasticLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachElasticLoadBalancerOutcomeCallable DetachElasticLoadBalancerCallable(const DetachElasticLoadBalancerRequestT& request) const { return SubmitCallable(&OpsWorksClient::DetachElasticLoadBalancer, request); } /** * An Async wrapper for DetachElasticLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachElasticLoadBalancerAsync(const DetachElasticLoadBalancerRequestT& request, const DetachElasticLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DetachElasticLoadBalancer, request, handler, context); } /** *

Disassociates an Elastic IP address from its instance. The address remains * registered with the stack. For more information, see Resource * Management.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateElasticIpOutcome DisassociateElasticIp(const Model::DisassociateElasticIpRequest& request) const; /** * A Callable wrapper for DisassociateElasticIp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateElasticIpOutcomeCallable DisassociateElasticIpCallable(const DisassociateElasticIpRequestT& request) const { return SubmitCallable(&OpsWorksClient::DisassociateElasticIp, request); } /** * An Async wrapper for DisassociateElasticIp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateElasticIpAsync(const DisassociateElasticIpRequestT& request, const DisassociateElasticIpResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::DisassociateElasticIp, request, handler, context); } /** *

Gets a generated host name for the specified layer, based on the current host * name theme.

Required Permissions: To use this action, an IAM user * must have a Manage permissions level for the stack, or an attached policy that * explicitly grants permissions. For more information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::GetHostnameSuggestionOutcome GetHostnameSuggestion(const Model::GetHostnameSuggestionRequest& request) const; /** * A Callable wrapper for GetHostnameSuggestion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetHostnameSuggestionOutcomeCallable GetHostnameSuggestionCallable(const GetHostnameSuggestionRequestT& request) const { return SubmitCallable(&OpsWorksClient::GetHostnameSuggestion, request); } /** * An Async wrapper for GetHostnameSuggestion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetHostnameSuggestionAsync(const GetHostnameSuggestionRequestT& request, const GetHostnameSuggestionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::GetHostnameSuggestion, request, handler, context); } /** *

This action can be used only with Windows stacks.

*

Grants RDP access to a Windows instance for a specified time * period.

See Also:

AWS * API Reference

*/ virtual Model::GrantAccessOutcome GrantAccess(const Model::GrantAccessRequest& request) const; /** * A Callable wrapper for GrantAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GrantAccessOutcomeCallable GrantAccessCallable(const GrantAccessRequestT& request) const { return SubmitCallable(&OpsWorksClient::GrantAccess, request); } /** * An Async wrapper for GrantAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GrantAccessAsync(const GrantAccessRequestT& request, const GrantAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::GrantAccess, request, handler, context); } /** *

Returns a list of tags that are applied to the specified stack or * layer.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const; /** * A Callable wrapper for ListTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const { return SubmitCallable(&OpsWorksClient::ListTags, request); } /** * An Async wrapper for ListTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::ListTags, request, handler, context); } /** *

Reboots a specified instance. For more information, see Starting, * Stopping, and Rebooting Instances.

Required Permissions: To * use this action, an IAM user must have a Manage permissions level for the stack, * or an attached policy that explicitly grants permissions. For more information * on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::RebootInstanceOutcome RebootInstance(const Model::RebootInstanceRequest& request) const; /** * A Callable wrapper for RebootInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebootInstanceOutcomeCallable RebootInstanceCallable(const RebootInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::RebootInstance, request); } /** * An Async wrapper for RebootInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebootInstanceAsync(const RebootInstanceRequestT& request, const RebootInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::RebootInstance, request, handler, context); } /** *

Registers a specified Amazon ECS cluster with a stack. You can register only * one cluster with a stack. A cluster can be registered with only one stack. For * more information, see * Resource Management.

Required Permissions: To use this * action, an IAM user must have a Manage permissions level for the stack or an * attached policy that explicitly grants permissions. For more information on user * permissions, see * Managing User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::RegisterEcsClusterOutcome RegisterEcsCluster(const Model::RegisterEcsClusterRequest& request) const; /** * A Callable wrapper for RegisterEcsCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterEcsClusterOutcomeCallable RegisterEcsClusterCallable(const RegisterEcsClusterRequestT& request) const { return SubmitCallable(&OpsWorksClient::RegisterEcsCluster, request); } /** * An Async wrapper for RegisterEcsCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterEcsClusterAsync(const RegisterEcsClusterRequestT& request, const RegisterEcsClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::RegisterEcsCluster, request, handler, context); } /** *

Registers an Elastic IP address with a specified stack. An address can be * registered with only one stack at a time. If the address is already registered, * you must first deregister it by calling DeregisterElasticIp. For more * information, see Resource * Management.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::RegisterElasticIpOutcome RegisterElasticIp(const Model::RegisterElasticIpRequest& request) const; /** * A Callable wrapper for RegisterElasticIp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterElasticIpOutcomeCallable RegisterElasticIpCallable(const RegisterElasticIpRequestT& request) const { return SubmitCallable(&OpsWorksClient::RegisterElasticIp, request); } /** * An Async wrapper for RegisterElasticIp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterElasticIpAsync(const RegisterElasticIpRequestT& request, const RegisterElasticIpResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::RegisterElasticIp, request, handler, context); } /** *

Registers instances that were created outside of AWS OpsWorks Stacks with a * specified stack.

We do not recommend using this action to register * instances. The complete registration operation includes two tasks: installing * the AWS OpsWorks Stacks agent on the instance, and registering the instance with * the stack. RegisterInstance handles only the second step. You * should instead use the AWS CLI register command, which performs the * entire registration operation. For more information, see * Registering an Instance with an AWS OpsWorks Stacks Stack.

*

Registered instances have the same requirements as instances that are created * by using the CreateInstance API. For example, registered instances must * be running a supported Linux-based operating system, and they must have a * supported instance type. For more information about requirements for instances * that you want to register, see * Preparing the Instance.

Required Permissions: To use this * action, an IAM user must have a Manage permissions level for the stack or an * attached policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::RegisterInstanceOutcome RegisterInstance(const Model::RegisterInstanceRequest& request) const; /** * A Callable wrapper for RegisterInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterInstanceOutcomeCallable RegisterInstanceCallable(const RegisterInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::RegisterInstance, request); } /** * An Async wrapper for RegisterInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterInstanceAsync(const RegisterInstanceRequestT& request, const RegisterInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::RegisterInstance, request, handler, context); } /** *

Registers an Amazon RDS instance with a stack.

Required * Permissions: To use this action, an IAM user must have a Manage permissions * level for the stack, or an attached policy that explicitly grants permissions. * For more information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::RegisterRdsDbInstanceOutcome RegisterRdsDbInstance(const Model::RegisterRdsDbInstanceRequest& request) const; /** * A Callable wrapper for RegisterRdsDbInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterRdsDbInstanceOutcomeCallable RegisterRdsDbInstanceCallable(const RegisterRdsDbInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::RegisterRdsDbInstance, request); } /** * An Async wrapper for RegisterRdsDbInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterRdsDbInstanceAsync(const RegisterRdsDbInstanceRequestT& request, const RegisterRdsDbInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::RegisterRdsDbInstance, request, handler, context); } /** *

Registers an Amazon EBS volume with a specified stack. A volume can be * registered with only one stack at a time. If the volume is already registered, * you must first deregister it by calling DeregisterVolume. For more * information, see Resource * Management.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::RegisterVolumeOutcome RegisterVolume(const Model::RegisterVolumeRequest& request) const; /** * A Callable wrapper for RegisterVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterVolumeOutcomeCallable RegisterVolumeCallable(const RegisterVolumeRequestT& request) const { return SubmitCallable(&OpsWorksClient::RegisterVolume, request); } /** * An Async wrapper for RegisterVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterVolumeAsync(const RegisterVolumeRequestT& request, const RegisterVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::RegisterVolume, request, handler, context); } /** *

Specify the load-based auto scaling configuration for a specified layer. For * more information, see Managing * Load with Time-based and Load-based Instances.

To use * load-based auto scaling, you must create a set of load-based auto scaling * instances. Load-based auto scaling operates only on the instances from that set, * so you must ensure that you have created enough instances to handle the maximum * anticipated load.

Required Permissions: To use this * action, an IAM user must have a Manage permissions level for the stack, or an * attached policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::SetLoadBasedAutoScalingOutcome SetLoadBasedAutoScaling(const Model::SetLoadBasedAutoScalingRequest& request) const; /** * A Callable wrapper for SetLoadBasedAutoScaling that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetLoadBasedAutoScalingOutcomeCallable SetLoadBasedAutoScalingCallable(const SetLoadBasedAutoScalingRequestT& request) const { return SubmitCallable(&OpsWorksClient::SetLoadBasedAutoScaling, request); } /** * An Async wrapper for SetLoadBasedAutoScaling that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetLoadBasedAutoScalingAsync(const SetLoadBasedAutoScalingRequestT& request, const SetLoadBasedAutoScalingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::SetLoadBasedAutoScaling, request, handler, context); } /** *

Specifies a user's permissions. For more information, see Security * and Permissions.

Required Permissions: To use this action, an * IAM user must have a Manage permissions level for the stack, or an attached * policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::SetPermissionOutcome SetPermission(const Model::SetPermissionRequest& request) const; /** * A Callable wrapper for SetPermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetPermissionOutcomeCallable SetPermissionCallable(const SetPermissionRequestT& request) const { return SubmitCallable(&OpsWorksClient::SetPermission, request); } /** * An Async wrapper for SetPermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetPermissionAsync(const SetPermissionRequestT& request, const SetPermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::SetPermission, request, handler, context); } /** *

Specify the time-based auto scaling configuration for a specified instance. * For more information, see Managing * Load with Time-based and Load-based Instances.

Required * Permissions: To use this action, an IAM user must have a Manage permissions * level for the stack, or an attached policy that explicitly grants permissions. * For more information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::SetTimeBasedAutoScalingOutcome SetTimeBasedAutoScaling(const Model::SetTimeBasedAutoScalingRequest& request) const; /** * A Callable wrapper for SetTimeBasedAutoScaling that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetTimeBasedAutoScalingOutcomeCallable SetTimeBasedAutoScalingCallable(const SetTimeBasedAutoScalingRequestT& request) const { return SubmitCallable(&OpsWorksClient::SetTimeBasedAutoScaling, request); } /** * An Async wrapper for SetTimeBasedAutoScaling that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetTimeBasedAutoScalingAsync(const SetTimeBasedAutoScalingRequestT& request, const SetTimeBasedAutoScalingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::SetTimeBasedAutoScaling, request, handler, context); } /** *

Starts a specified instance. For more information, see Starting, * Stopping, and Rebooting Instances.

Required Permissions: To * use this action, an IAM user must have a Manage permissions level for the stack, * or an attached policy that explicitly grants permissions. For more information * on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::StartInstanceOutcome StartInstance(const Model::StartInstanceRequest& request) const; /** * A Callable wrapper for StartInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartInstanceOutcomeCallable StartInstanceCallable(const StartInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::StartInstance, request); } /** * An Async wrapper for StartInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartInstanceAsync(const StartInstanceRequestT& request, const StartInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::StartInstance, request, handler, context); } /** *

Starts a stack's instances.

Required Permissions: To use this * action, an IAM user must have a Manage permissions level for the stack, or an * attached policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::StartStackOutcome StartStack(const Model::StartStackRequest& request) const; /** * A Callable wrapper for StartStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartStackOutcomeCallable StartStackCallable(const StartStackRequestT& request) const { return SubmitCallable(&OpsWorksClient::StartStack, request); } /** * An Async wrapper for StartStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartStackAsync(const StartStackRequestT& request, const StartStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::StartStack, request, handler, context); } /** *

Stops a specified instance. When you stop a standard instance, the data * disappears and must be reinstalled when you restart the instance. You can stop * an Amazon EBS-backed instance without losing data. For more information, see Starting, * Stopping, and Rebooting Instances.

Required Permissions: To * use this action, an IAM user must have a Manage permissions level for the stack, * or an attached policy that explicitly grants permissions. For more information * on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::StopInstanceOutcome StopInstance(const Model::StopInstanceRequest& request) const; /** * A Callable wrapper for StopInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopInstanceOutcomeCallable StopInstanceCallable(const StopInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::StopInstance, request); } /** * An Async wrapper for StopInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopInstanceAsync(const StopInstanceRequestT& request, const StopInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::StopInstance, request, handler, context); } /** *

Stops a specified stack.

Required Permissions: To use this * action, an IAM user must have a Manage permissions level for the stack, or an * attached policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::StopStackOutcome StopStack(const Model::StopStackRequest& request) const; /** * A Callable wrapper for StopStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopStackOutcomeCallable StopStackCallable(const StopStackRequestT& request) const { return SubmitCallable(&OpsWorksClient::StopStack, request); } /** * An Async wrapper for StopStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopStackAsync(const StopStackRequestT& request, const StopStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::StopStack, request, handler, context); } /** *

Apply cost-allocation tags to a specified stack or layer in AWS OpsWorks * Stacks. For more information about how tagging works, see Tags * in the AWS OpsWorks User Guide.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&OpsWorksClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::TagResource, request, handler, context); } /** *

Unassigns a registered instance from all layers that are using the instance. * The instance remains in the stack as an unassigned instance, and can be assigned * to another layer as needed. You cannot use this action with instances that were * created with AWS OpsWorks Stacks.

Required Permissions: To use * this action, an IAM user must have a Manage permissions level for the stack or * an attached policy that explicitly grants permissions. For more information * about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UnassignInstanceOutcome UnassignInstance(const Model::UnassignInstanceRequest& request) const; /** * A Callable wrapper for UnassignInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UnassignInstanceOutcomeCallable UnassignInstanceCallable(const UnassignInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::UnassignInstance, request); } /** * An Async wrapper for UnassignInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UnassignInstanceAsync(const UnassignInstanceRequestT& request, const UnassignInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UnassignInstance, request, handler, context); } /** *

Unassigns an assigned Amazon EBS volume. The volume remains registered with * the stack. For more information, see Resource * Management.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UnassignVolumeOutcome UnassignVolume(const Model::UnassignVolumeRequest& request) const; /** * A Callable wrapper for UnassignVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UnassignVolumeOutcomeCallable UnassignVolumeCallable(const UnassignVolumeRequestT& request) const { return SubmitCallable(&OpsWorksClient::UnassignVolume, request); } /** * An Async wrapper for UnassignVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UnassignVolumeAsync(const UnassignVolumeRequestT& request, const UnassignVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UnassignVolume, request, handler, context); } /** *

Removes tags from a specified stack or layer.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&OpsWorksClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UntagResource, request, handler, context); } /** *

Updates a specified app.

Required Permissions: To use this * action, an IAM user must have a Deploy or Manage permissions level for the * stack, or an attached policy that explicitly grants permissions. For more * information on user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAppOutcome UpdateApp(const Model::UpdateAppRequest& request) const; /** * A Callable wrapper for UpdateApp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAppOutcomeCallable UpdateAppCallable(const UpdateAppRequestT& request) const { return SubmitCallable(&OpsWorksClient::UpdateApp, request); } /** * An Async wrapper for UpdateApp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAppAsync(const UpdateAppRequestT& request, const UpdateAppResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UpdateApp, request, handler, context); } /** *

Updates a registered Elastic IP address's name. For more information, see Resource * Management.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UpdateElasticIpOutcome UpdateElasticIp(const Model::UpdateElasticIpRequest& request) const; /** * A Callable wrapper for UpdateElasticIp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateElasticIpOutcomeCallable UpdateElasticIpCallable(const UpdateElasticIpRequestT& request) const { return SubmitCallable(&OpsWorksClient::UpdateElasticIp, request); } /** * An Async wrapper for UpdateElasticIp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateElasticIpAsync(const UpdateElasticIpRequestT& request, const UpdateElasticIpResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UpdateElasticIp, request, handler, context); } /** *

Updates a specified instance.

Required Permissions: To use * this action, an IAM user must have a Manage permissions level for the stack, or * an attached policy that explicitly grants permissions. For more information on * user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UpdateInstanceOutcome UpdateInstance(const Model::UpdateInstanceRequest& request) const; /** * A Callable wrapper for UpdateInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateInstanceOutcomeCallable UpdateInstanceCallable(const UpdateInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::UpdateInstance, request); } /** * An Async wrapper for UpdateInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateInstanceAsync(const UpdateInstanceRequestT& request, const UpdateInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UpdateInstance, request, handler, context); } /** *

Updates a specified layer.

Required Permissions: To use this * action, an IAM user must have a Manage permissions level for the stack, or an * attached policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UpdateLayerOutcome UpdateLayer(const Model::UpdateLayerRequest& request) const; /** * A Callable wrapper for UpdateLayer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateLayerOutcomeCallable UpdateLayerCallable(const UpdateLayerRequestT& request) const { return SubmitCallable(&OpsWorksClient::UpdateLayer, request); } /** * An Async wrapper for UpdateLayer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateLayerAsync(const UpdateLayerRequestT& request, const UpdateLayerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UpdateLayer, request, handler, context); } /** *

Updates a user's SSH public key.

Required Permissions: To use * this action, an IAM user must have self-management enabled or an attached policy * that explicitly grants permissions. For more information about user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UpdateMyUserProfileOutcome UpdateMyUserProfile(const Model::UpdateMyUserProfileRequest& request) const; /** * A Callable wrapper for UpdateMyUserProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateMyUserProfileOutcomeCallable UpdateMyUserProfileCallable(const UpdateMyUserProfileRequestT& request) const { return SubmitCallable(&OpsWorksClient::UpdateMyUserProfile, request); } /** * An Async wrapper for UpdateMyUserProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateMyUserProfileAsync(const UpdateMyUserProfileRequestT& request, const UpdateMyUserProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UpdateMyUserProfile, request, handler, context); } /** *

Updates an Amazon RDS instance.

Required Permissions: To use * this action, an IAM user must have a Manage permissions level for the stack, or * an attached policy that explicitly grants permissions. For more information on * user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRdsDbInstanceOutcome UpdateRdsDbInstance(const Model::UpdateRdsDbInstanceRequest& request) const; /** * A Callable wrapper for UpdateRdsDbInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRdsDbInstanceOutcomeCallable UpdateRdsDbInstanceCallable(const UpdateRdsDbInstanceRequestT& request) const { return SubmitCallable(&OpsWorksClient::UpdateRdsDbInstance, request); } /** * An Async wrapper for UpdateRdsDbInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRdsDbInstanceAsync(const UpdateRdsDbInstanceRequestT& request, const UpdateRdsDbInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UpdateRdsDbInstance, request, handler, context); } /** *

Updates a specified stack.

Required Permissions: To use this * action, an IAM user must have a Manage permissions level for the stack, or an * attached policy that explicitly grants permissions. For more information on user * permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UpdateStackOutcome UpdateStack(const Model::UpdateStackRequest& request) const; /** * A Callable wrapper for UpdateStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStackOutcomeCallable UpdateStackCallable(const UpdateStackRequestT& request) const { return SubmitCallable(&OpsWorksClient::UpdateStack, request); } /** * An Async wrapper for UpdateStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStackAsync(const UpdateStackRequestT& request, const UpdateStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UpdateStack, request, handler, context); } /** *

Updates a specified user profile.

Required Permissions: To use * this action, an IAM user must have an attached policy that explicitly grants * permissions. For more information about user permissions, see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UpdateUserProfileOutcome UpdateUserProfile(const Model::UpdateUserProfileRequest& request) const; /** * A Callable wrapper for UpdateUserProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateUserProfileOutcomeCallable UpdateUserProfileCallable(const UpdateUserProfileRequestT& request) const { return SubmitCallable(&OpsWorksClient::UpdateUserProfile, request); } /** * An Async wrapper for UpdateUserProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateUserProfileAsync(const UpdateUserProfileRequestT& request, const UpdateUserProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UpdateUserProfile, request, handler, context); } /** *

Updates an Amazon EBS volume's name or mount point. For more information, see * Resource * Management.

Required Permissions: To use this action, an IAM * user must have a Manage permissions level for the stack, or an attached policy * that explicitly grants permissions. For more information on user permissions, * see Managing * User Permissions.

See Also:

AWS * API Reference

*/ virtual Model::UpdateVolumeOutcome UpdateVolume(const Model::UpdateVolumeRequest& request) const; /** * A Callable wrapper for UpdateVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateVolumeOutcomeCallable UpdateVolumeCallable(const UpdateVolumeRequestT& request) const { return SubmitCallable(&OpsWorksClient::UpdateVolume, request); } /** * An Async wrapper for UpdateVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateVolumeAsync(const UpdateVolumeRequestT& request, const UpdateVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OpsWorksClient::UpdateVolume, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const OpsWorksClientConfiguration& clientConfiguration); OpsWorksClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace OpsWorks } // namespace Aws