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

CloudFormation allows you to create and * manage Amazon Web Services infrastructure deployments predictably and * repeatedly. You can use CloudFormation to leverage Amazon Web Services products, * such as Amazon Elastic Compute Cloud, Amazon Elastic Block Store, Amazon Simple * Notification Service, Elastic Load Balancing, and Auto Scaling to build highly * reliable, highly scalable, cost-effective applications without creating or * configuring the underlying Amazon Web Services infrastructure.

With * CloudFormation, you declare all your resources and dependencies in a template * file. The template defines a collection of resources as a single unit called a * stack. CloudFormation creates and deletes all member resources of the stack * together and manages all dependencies between the resources for you.

For * more information about CloudFormation, see the CloudFormation product * page.

CloudFormation makes use of other Amazon Web Services products. * If you need additional technical information about a specific Amazon Web * Services product, you can find the product's technical documentation at docs.aws.amazon.com.

*/ class AWS_CLOUDFORMATION_API CloudFormationClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef CloudFormationClientConfiguration ClientConfigurationType; typedef CloudFormationEndpointProvider 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. */ CloudFormationClient(const Aws::CloudFormation::CloudFormationClientConfiguration& clientConfiguration = Aws::CloudFormation::CloudFormationClientConfiguration(), 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. */ CloudFormationClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CloudFormation::CloudFormationClientConfiguration& clientConfiguration = Aws::CloudFormation::CloudFormationClientConfiguration()); /** * 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 */ CloudFormationClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CloudFormation::CloudFormationClientConfiguration& clientConfiguration = Aws::CloudFormation::CloudFormationClientConfiguration()); /* 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. */ CloudFormationClient(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. */ CloudFormationClient(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 */ CloudFormationClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~CloudFormationClient(); /** * Converts any request object to a presigned URL with the GET method, using region for the signer and a timeout of 15 minutes. */ Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const; /** *

Activate trusted access with Organizations. With trusted access between * StackSets and Organizations activated, the management account has permissions to * create and manage StackSets for your organization.

See Also:

AWS * API Reference

*/ virtual Model::ActivateOrganizationsAccessOutcome ActivateOrganizationsAccess(const Model::ActivateOrganizationsAccessRequest& request) const; /** * A Callable wrapper for ActivateOrganizationsAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ActivateOrganizationsAccessOutcomeCallable ActivateOrganizationsAccessCallable(const ActivateOrganizationsAccessRequestT& request) const { return SubmitCallable(&CloudFormationClient::ActivateOrganizationsAccess, request); } /** * An Async wrapper for ActivateOrganizationsAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ActivateOrganizationsAccessAsync(const ActivateOrganizationsAccessRequestT& request, const ActivateOrganizationsAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ActivateOrganizationsAccess, request, handler, context); } /** *

Activates a public third-party extension, making it available for use in * stack templates. For more information, see Using * public extensions in the CloudFormation User Guide.

Once you * have activated a public third-party extension in your account and Region, use SetTypeConfiguration * to specify configuration properties for the extension. For more information, see * Configuring * extensions at the account level in the CloudFormation User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ActivateTypeOutcome ActivateType(const Model::ActivateTypeRequest& request) const; /** * A Callable wrapper for ActivateType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ActivateTypeOutcomeCallable ActivateTypeCallable(const ActivateTypeRequestT& request) const { return SubmitCallable(&CloudFormationClient::ActivateType, request); } /** * An Async wrapper for ActivateType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ActivateTypeAsync(const ActivateTypeRequestT& request, const ActivateTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ActivateType, request, handler, context); } /** *

Returns configuration data for the specified CloudFormation extensions, from * the CloudFormation registry for the account and Region.

For more * information, see Configuring * extensions at the account level in the CloudFormation User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::BatchDescribeTypeConfigurationsOutcome BatchDescribeTypeConfigurations(const Model::BatchDescribeTypeConfigurationsRequest& request) const; /** * A Callable wrapper for BatchDescribeTypeConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDescribeTypeConfigurationsOutcomeCallable BatchDescribeTypeConfigurationsCallable(const BatchDescribeTypeConfigurationsRequestT& request) const { return SubmitCallable(&CloudFormationClient::BatchDescribeTypeConfigurations, request); } /** * An Async wrapper for BatchDescribeTypeConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDescribeTypeConfigurationsAsync(const BatchDescribeTypeConfigurationsRequestT& request, const BatchDescribeTypeConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::BatchDescribeTypeConfigurations, request, handler, context); } /** *

Cancels an update on the specified stack. If the call completes successfully, * the stack rolls back the update and reverts to the previous stack * configuration.

You can cancel only stacks that are in the * UPDATE_IN_PROGRESS state.

See Also:

AWS * API Reference

*/ virtual Model::CancelUpdateStackOutcome CancelUpdateStack(const Model::CancelUpdateStackRequest& request) const; /** * A Callable wrapper for CancelUpdateStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelUpdateStackOutcomeCallable CancelUpdateStackCallable(const CancelUpdateStackRequestT& request) const { return SubmitCallable(&CloudFormationClient::CancelUpdateStack, request); } /** * An Async wrapper for CancelUpdateStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelUpdateStackAsync(const CancelUpdateStackRequestT& request, const CancelUpdateStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::CancelUpdateStack, request, handler, context); } /** *

For a specified stack that's in the UPDATE_ROLLBACK_FAILED * state, continues rolling it back to the UPDATE_ROLLBACK_COMPLETE * state. Depending on the cause of the failure, you can manually * fix the error and continue the rollback. By continuing the rollback, you can * return your stack to a working state (the UPDATE_ROLLBACK_COMPLETE * state), and then try to update the stack again.

A stack goes into the * UPDATE_ROLLBACK_FAILED state when CloudFormation can't roll back * all changes after a failed stack update. For example, you might have a stack * that's rolling back to an old database instance that was deleted outside of * CloudFormation. Because CloudFormation doesn't know the database was deleted, it * assumes that the database instance still exists and attempts to roll back to it, * causing the update rollback to fail.

See Also:

AWS * API Reference

*/ virtual Model::ContinueUpdateRollbackOutcome ContinueUpdateRollback(const Model::ContinueUpdateRollbackRequest& request) const; /** * A Callable wrapper for ContinueUpdateRollback that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ContinueUpdateRollbackOutcomeCallable ContinueUpdateRollbackCallable(const ContinueUpdateRollbackRequestT& request) const { return SubmitCallable(&CloudFormationClient::ContinueUpdateRollback, request); } /** * An Async wrapper for ContinueUpdateRollback that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ContinueUpdateRollbackAsync(const ContinueUpdateRollbackRequestT& request, const ContinueUpdateRollbackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ContinueUpdateRollback, request, handler, context); } /** *

Creates a list of changes that will be applied to a stack so that you can * review the changes before executing them. You can create a change set for a * stack that doesn't exist or an existing stack. If you create a change set for a * stack that doesn't exist, the change set shows all of the resources that * CloudFormation will create. If you create a change set for an existing stack, * CloudFormation compares the stack's information with the information that you * submit in the change set and lists the differences. Use change sets to * understand which resources CloudFormation will create or change, and how it will * change resources in an existing stack, before you create or update a stack.

*

To create a change set for a stack that doesn't exist, for the * ChangeSetType parameter, specify CREATE. To create a * change set for an existing stack, specify UPDATE for the * ChangeSetType parameter. To create a change set for an import * operation, specify IMPORT for the ChangeSetType * parameter. After the CreateChangeSet call successfully completes, * CloudFormation starts creating the change set. To check the status of the change * set or to review it, use the DescribeChangeSet action.

When you * are satisfied with the changes the change set will make, execute the change set * by using the ExecuteChangeSet action. CloudFormation doesn't make changes * until you execute the change set.

To create a change set for the entire * stack hierarchy, set IncludeNestedStacks to * True.

See Also:

AWS * API Reference

*/ virtual Model::CreateChangeSetOutcome CreateChangeSet(const Model::CreateChangeSetRequest& request) const; /** * A Callable wrapper for CreateChangeSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateChangeSetOutcomeCallable CreateChangeSetCallable(const CreateChangeSetRequestT& request) const { return SubmitCallable(&CloudFormationClient::CreateChangeSet, request); } /** * An Async wrapper for CreateChangeSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateChangeSetAsync(const CreateChangeSetRequestT& request, const CreateChangeSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::CreateChangeSet, request, handler, context); } /** *

Creates a stack as specified in the template. After the call completes * successfully, the stack creation starts. You can check the status of the stack * through the DescribeStacks operation.

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(&CloudFormationClient::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(&CloudFormationClient::CreateStack, request, handler, context); } /** *

Creates stack instances for the specified accounts, within the specified * Amazon Web Services Regions. A stack instance refers to a stack in a specific * account and Region. You must specify at least one value for either * Accounts or DeploymentTargets, and you must specify at * least one value for Regions.

See Also:

AWS * API Reference

*/ virtual Model::CreateStackInstancesOutcome CreateStackInstances(const Model::CreateStackInstancesRequest& request) const; /** * A Callable wrapper for CreateStackInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStackInstancesOutcomeCallable CreateStackInstancesCallable(const CreateStackInstancesRequestT& request) const { return SubmitCallable(&CloudFormationClient::CreateStackInstances, request); } /** * An Async wrapper for CreateStackInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStackInstancesAsync(const CreateStackInstancesRequestT& request, const CreateStackInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::CreateStackInstances, request, handler, context); } /** *

Creates a stack set.

See Also:

AWS * API Reference

*/ virtual Model::CreateStackSetOutcome CreateStackSet(const Model::CreateStackSetRequest& request) const; /** * A Callable wrapper for CreateStackSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStackSetOutcomeCallable CreateStackSetCallable(const CreateStackSetRequestT& request) const { return SubmitCallable(&CloudFormationClient::CreateStackSet, request); } /** * An Async wrapper for CreateStackSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStackSetAsync(const CreateStackSetRequestT& request, const CreateStackSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::CreateStackSet, request, handler, context); } /** *

Deactivates trusted access with Organizations. If trusted access is * deactivated, the management account does not have permissions to create and * manage service-managed StackSets for your organization.

See Also:

* AWS * API Reference

*/ virtual Model::DeactivateOrganizationsAccessOutcome DeactivateOrganizationsAccess(const Model::DeactivateOrganizationsAccessRequest& request) const; /** * A Callable wrapper for DeactivateOrganizationsAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeactivateOrganizationsAccessOutcomeCallable DeactivateOrganizationsAccessCallable(const DeactivateOrganizationsAccessRequestT& request) const { return SubmitCallable(&CloudFormationClient::DeactivateOrganizationsAccess, request); } /** * An Async wrapper for DeactivateOrganizationsAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeactivateOrganizationsAccessAsync(const DeactivateOrganizationsAccessRequestT& request, const DeactivateOrganizationsAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DeactivateOrganizationsAccess, request, handler, context); } /** *

Deactivates a public extension that was previously activated in this account * and Region.

Once deactivated, an extension can't be used in any * CloudFormation operation. This includes stack update operations where the stack * template includes the extension, even if no updates are being made to the * extension. In addition, deactivated extensions aren't automatically updated if a * new version of the extension is released.

See Also:

AWS * API Reference

*/ virtual Model::DeactivateTypeOutcome DeactivateType(const Model::DeactivateTypeRequest& request) const; /** * A Callable wrapper for DeactivateType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeactivateTypeOutcomeCallable DeactivateTypeCallable(const DeactivateTypeRequestT& request) const { return SubmitCallable(&CloudFormationClient::DeactivateType, request); } /** * An Async wrapper for DeactivateType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeactivateTypeAsync(const DeactivateTypeRequestT& request, const DeactivateTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DeactivateType, request, handler, context); } /** *

Deletes the specified change set. Deleting change sets ensures that no one * executes the wrong change set.

If the call successfully completes, * CloudFormation successfully deleted the change set.

If * IncludeNestedStacks specifies True during the creation * of the nested change set, then DeleteChangeSet will delete all * change sets that belong to the stacks hierarchy and will also delete all change * sets for nested stacks with the status of * REVIEW_IN_PROGRESS.

See Also:

AWS * API Reference

*/ virtual Model::DeleteChangeSetOutcome DeleteChangeSet(const Model::DeleteChangeSetRequest& request) const; /** * A Callable wrapper for DeleteChangeSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteChangeSetOutcomeCallable DeleteChangeSetCallable(const DeleteChangeSetRequestT& request) const { return SubmitCallable(&CloudFormationClient::DeleteChangeSet, request); } /** * An Async wrapper for DeleteChangeSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteChangeSetAsync(const DeleteChangeSetRequestT& request, const DeleteChangeSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DeleteChangeSet, request, handler, context); } /** *

Deletes a specified stack. Once the call completes successfully, stack * deletion starts. Deleted stacks don't show up in the DescribeStacks * operation if the deletion has been completed successfully.

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(&CloudFormationClient::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(&CloudFormationClient::DeleteStack, request, handler, context); } /** *

Deletes stack instances for the specified accounts, in the specified Amazon * Web Services Regions.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStackInstancesOutcome DeleteStackInstances(const Model::DeleteStackInstancesRequest& request) const; /** * A Callable wrapper for DeleteStackInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStackInstancesOutcomeCallable DeleteStackInstancesCallable(const DeleteStackInstancesRequestT& request) const { return SubmitCallable(&CloudFormationClient::DeleteStackInstances, request); } /** * An Async wrapper for DeleteStackInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStackInstancesAsync(const DeleteStackInstancesRequestT& request, const DeleteStackInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DeleteStackInstances, request, handler, context); } /** *

Deletes a stack set. Before you can delete a stack set, all its member stack * instances must be deleted. For more information about how to complete this, see * DeleteStackInstances.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStackSetOutcome DeleteStackSet(const Model::DeleteStackSetRequest& request) const; /** * A Callable wrapper for DeleteStackSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStackSetOutcomeCallable DeleteStackSetCallable(const DeleteStackSetRequestT& request) const { return SubmitCallable(&CloudFormationClient::DeleteStackSet, request); } /** * An Async wrapper for DeleteStackSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStackSetAsync(const DeleteStackSetRequestT& request, const DeleteStackSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DeleteStackSet, request, handler, context); } /** *

Marks an extension or extension version as DEPRECATED in the * CloudFormation registry, removing it from active use. Deprecated extensions or * extension versions cannot be used in CloudFormation operations.

To * deregister an entire extension, you must individually deregister all active * versions of that extension. If an extension has only a single active version, * deregistering that version results in the extension itself being deregistered * and marked as deprecated in the registry.

You can't deregister the * default version of an extension if there are other active version of that * extension. If you do deregister the default version of an extension, the * extension type itself is deregistered as well and marked as deprecated.

*

To view the deprecation status of an extension or extension version, use DescribeType.

See * Also:

AWS * API Reference

*/ virtual Model::DeregisterTypeOutcome DeregisterType(const Model::DeregisterTypeRequest& request) const; /** * A Callable wrapper for DeregisterType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterTypeOutcomeCallable DeregisterTypeCallable(const DeregisterTypeRequestT& request) const { return SubmitCallable(&CloudFormationClient::DeregisterType, request); } /** * An Async wrapper for DeregisterType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterTypeAsync(const DeregisterTypeRequestT& request, const DeregisterTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DeregisterType, request, handler, context); } /** *

Retrieves your account's CloudFormation limits, such as the maximum number of * stacks that you can create in your account. For more information about account * limits, see CloudFormation * Quotas in the CloudFormation User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeAccountLimitsOutcome DescribeAccountLimits(const Model::DescribeAccountLimitsRequest& request) const; /** * A Callable wrapper for DescribeAccountLimits that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountLimitsOutcomeCallable DescribeAccountLimitsCallable(const DescribeAccountLimitsRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeAccountLimits, request); } /** * An Async wrapper for DescribeAccountLimits that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountLimitsAsync(const DescribeAccountLimitsRequestT& request, const DescribeAccountLimitsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeAccountLimits, request, handler, context); } /** *

Returns the inputs for the change set and a list of changes that * CloudFormation will make if you execute the change set. For more information, * see Updating * Stacks Using Change Sets in the CloudFormation User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeChangeSetOutcome DescribeChangeSet(const Model::DescribeChangeSetRequest& request) const; /** * A Callable wrapper for DescribeChangeSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeChangeSetOutcomeCallable DescribeChangeSetCallable(const DescribeChangeSetRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeChangeSet, request); } /** * An Async wrapper for DescribeChangeSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeChangeSetAsync(const DescribeChangeSetRequestT& request, const DescribeChangeSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeChangeSet, request, handler, context); } /** *

Returns hook-related information for the change set and a list of changes * that CloudFormation makes when you run the change set.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeChangeSetHooksOutcome DescribeChangeSetHooks(const Model::DescribeChangeSetHooksRequest& request) const; /** * A Callable wrapper for DescribeChangeSetHooks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeChangeSetHooksOutcomeCallable DescribeChangeSetHooksCallable(const DescribeChangeSetHooksRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeChangeSetHooks, request); } /** * An Async wrapper for DescribeChangeSetHooks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeChangeSetHooksAsync(const DescribeChangeSetHooksRequestT& request, const DescribeChangeSetHooksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeChangeSetHooks, request, handler, context); } /** *

Retrieves information about the account's OrganizationAccess * status. This API can be called either by the management account or the delegated * administrator by using the CallAs parameter. This API can also be * called without the CallAs parameter by the management * account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOrganizationsAccessOutcome DescribeOrganizationsAccess(const Model::DescribeOrganizationsAccessRequest& request) const; /** * A Callable wrapper for DescribeOrganizationsAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOrganizationsAccessOutcomeCallable DescribeOrganizationsAccessCallable(const DescribeOrganizationsAccessRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeOrganizationsAccess, request); } /** * An Async wrapper for DescribeOrganizationsAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOrganizationsAccessAsync(const DescribeOrganizationsAccessRequestT& request, const DescribeOrganizationsAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeOrganizationsAccess, request, handler, context); } /** *

Returns information about a CloudFormation extension publisher.

If you * don't supply a PublisherId, and you have registered as an extension * publisher, DescribePublisher returns information about your own * publisher account.

For more information about registering as a publisher, * see:

See Also:

AWS * API Reference

*/ virtual Model::DescribePublisherOutcome DescribePublisher(const Model::DescribePublisherRequest& request) const; /** * A Callable wrapper for DescribePublisher that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePublisherOutcomeCallable DescribePublisherCallable(const DescribePublisherRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribePublisher, request); } /** * An Async wrapper for DescribePublisher that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePublisherAsync(const DescribePublisherRequestT& request, const DescribePublisherResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribePublisher, request, handler, context); } /** *

Returns information about a stack drift detection operation. A stack drift * detection operation detects whether a stack's actual configuration differs, or * has drifted, from its expected configuration, as defined in the stack * template and any values specified as template parameters. A stack is considered * to have drifted if one or more of its resources have drifted. For more * information about stack and resource drift, see Detecting * Unregulated Configuration Changes to Stacks and Resources.

Use * DetectStackDrift to initiate a stack drift detection operation. * DetectStackDrift returns a StackDriftDetectionId you * can use to monitor the progress of the operation using * DescribeStackDriftDetectionStatus. Once the drift detection * operation has completed, use DescribeStackResourceDrifts to return drift * information about the stack and its resources.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStackDriftDetectionStatusOutcome DescribeStackDriftDetectionStatus(const Model::DescribeStackDriftDetectionStatusRequest& request) const; /** * A Callable wrapper for DescribeStackDriftDetectionStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStackDriftDetectionStatusOutcomeCallable DescribeStackDriftDetectionStatusCallable(const DescribeStackDriftDetectionStatusRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeStackDriftDetectionStatus, request); } /** * An Async wrapper for DescribeStackDriftDetectionStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStackDriftDetectionStatusAsync(const DescribeStackDriftDetectionStatusRequestT& request, const DescribeStackDriftDetectionStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeStackDriftDetectionStatus, request, handler, context); } /** *

Returns all stack related events for a specified stack in reverse * chronological order. For more information about a stack's event history, go to * Stacks * in the CloudFormation User Guide.

You can list events for stacks * that have failed to create or have been deleted by specifying the unique stack * identifier (stack ID).

See Also:

AWS * API Reference

*/ virtual Model::DescribeStackEventsOutcome DescribeStackEvents(const Model::DescribeStackEventsRequest& request) const; /** * A Callable wrapper for DescribeStackEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStackEventsOutcomeCallable DescribeStackEventsCallable(const DescribeStackEventsRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeStackEvents, request); } /** * An Async wrapper for DescribeStackEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStackEventsAsync(const DescribeStackEventsRequestT& request, const DescribeStackEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeStackEvents, request, handler, context); } /** *

Returns the stack instance that's associated with the specified StackSet, * Amazon Web Services account, and Amazon Web Services Region.

For a list * of stack instances that are associated with a specific StackSet, use * ListStackInstances.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStackInstanceOutcome DescribeStackInstance(const Model::DescribeStackInstanceRequest& request) const; /** * A Callable wrapper for DescribeStackInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStackInstanceOutcomeCallable DescribeStackInstanceCallable(const DescribeStackInstanceRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeStackInstance, request); } /** * An Async wrapper for DescribeStackInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStackInstanceAsync(const DescribeStackInstanceRequestT& request, const DescribeStackInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeStackInstance, request, handler, context); } /** *

Returns a description of the specified resource in the specified stack.

*

For deleted stacks, DescribeStackResource returns resource information for up * to 90 days after the stack has been deleted.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStackResourceOutcome DescribeStackResource(const Model::DescribeStackResourceRequest& request) const; /** * A Callable wrapper for DescribeStackResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStackResourceOutcomeCallable DescribeStackResourceCallable(const DescribeStackResourceRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeStackResource, request); } /** * An Async wrapper for DescribeStackResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStackResourceAsync(const DescribeStackResourceRequestT& request, const DescribeStackResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeStackResource, request, handler, context); } /** *

Returns drift information for the resources that have been checked for drift * in the specified stack. This includes actual and expected configuration values * for resources where CloudFormation detects configuration drift.

For a * given stack, there will be one StackResourceDrift for each stack * resource that has been checked for drift. Resources that haven't yet been * checked for drift aren't included. Resources that don't currently support drift * detection aren't checked, and so not included. For a list of resources that * support drift detection, see Resources * that Support Drift Detection.

Use DetectStackResourceDrift to * detect drift on individual resources, or DetectStackDrift to detect drift * on all supported resources for a given stack.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStackResourceDriftsOutcome DescribeStackResourceDrifts(const Model::DescribeStackResourceDriftsRequest& request) const; /** * A Callable wrapper for DescribeStackResourceDrifts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStackResourceDriftsOutcomeCallable DescribeStackResourceDriftsCallable(const DescribeStackResourceDriftsRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeStackResourceDrifts, request); } /** * An Async wrapper for DescribeStackResourceDrifts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStackResourceDriftsAsync(const DescribeStackResourceDriftsRequestT& request, const DescribeStackResourceDriftsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeStackResourceDrifts, request, handler, context); } /** *

Returns Amazon Web Services resource descriptions for running and deleted * stacks. If StackName is specified, all the associated resources * that are part of the stack are returned. If PhysicalResourceId is * specified, the associated resources of the stack that the resource belongs to * are returned.

Only the first 100 resources will be returned. If * your stack has more resources than this, you should use * ListStackResources instead.

For deleted stacks, * DescribeStackResources returns resource information for up to 90 * days after the stack has been deleted.

You must specify either * StackName or PhysicalResourceId, but not both. In * addition, you can specify LogicalResourceId to filter the returned * result. For more information about resources, the LogicalResourceId * and PhysicalResourceId, go to the CloudFormation * User Guide.

A ValidationError is returned if you * specify both StackName and PhysicalResourceId in the * same request.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStackResourcesOutcome DescribeStackResources(const Model::DescribeStackResourcesRequest& request) const; /** * A Callable wrapper for DescribeStackResources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStackResourcesOutcomeCallable DescribeStackResourcesCallable(const DescribeStackResourcesRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeStackResources, request); } /** * An Async wrapper for DescribeStackResources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStackResourcesAsync(const DescribeStackResourcesRequestT& request, const DescribeStackResourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeStackResources, request, handler, context); } /** *

Returns the description of the specified StackSet.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeStackSetOutcome DescribeStackSet(const Model::DescribeStackSetRequest& request) const; /** * A Callable wrapper for DescribeStackSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStackSetOutcomeCallable DescribeStackSetCallable(const DescribeStackSetRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeStackSet, request); } /** * An Async wrapper for DescribeStackSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStackSetAsync(const DescribeStackSetRequestT& request, const DescribeStackSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeStackSet, request, handler, context); } /** *

Returns the description of the specified StackSet operation.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeStackSetOperationOutcome DescribeStackSetOperation(const Model::DescribeStackSetOperationRequest& request) const; /** * A Callable wrapper for DescribeStackSetOperation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStackSetOperationOutcomeCallable DescribeStackSetOperationCallable(const DescribeStackSetOperationRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeStackSetOperation, request); } /** * An Async wrapper for DescribeStackSetOperation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStackSetOperationAsync(const DescribeStackSetOperationRequestT& request, const DescribeStackSetOperationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeStackSetOperation, request, handler, context); } /** *

Returns the description for the specified stack; if no stack name was * specified, then it returns the description for all the stacks created.

*

If the stack doesn't exist, an ValidationError is * returned.

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(&CloudFormationClient::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(&CloudFormationClient::DescribeStacks, request, handler, context); } /** *

Returns detailed information about an extension that has been registered.

*

If you specify a VersionId, DescribeType returns * information about that specific extension version. Otherwise, it returns * information about the default extension version.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTypeOutcome DescribeType(const Model::DescribeTypeRequest& request) const; /** * A Callable wrapper for DescribeType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTypeOutcomeCallable DescribeTypeCallable(const DescribeTypeRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeType, request); } /** * An Async wrapper for DescribeType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTypeAsync(const DescribeTypeRequestT& request, const DescribeTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeType, request, handler, context); } /** *

Returns information about an extension's registration, including its current * status and type and version identifiers.

When you initiate a registration * request using RegisterType, you can then use * DescribeTypeRegistration to monitor the progress of that registration * request.

Once the registration request has completed, use * DescribeType to return detailed information about an * extension.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTypeRegistrationOutcome DescribeTypeRegistration(const Model::DescribeTypeRegistrationRequest& request) const; /** * A Callable wrapper for DescribeTypeRegistration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTypeRegistrationOutcomeCallable DescribeTypeRegistrationCallable(const DescribeTypeRegistrationRequestT& request) const { return SubmitCallable(&CloudFormationClient::DescribeTypeRegistration, request); } /** * An Async wrapper for DescribeTypeRegistration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTypeRegistrationAsync(const DescribeTypeRegistrationRequestT& request, const DescribeTypeRegistrationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DescribeTypeRegistration, request, handler, context); } /** *

Detects whether a stack's actual configuration differs, or has * drifted, from its expected configuration, as defined in the stack * template and any values specified as template parameters. For each resource in * the stack that supports drift detection, CloudFormation compares the actual * configuration of the resource with its expected template configuration. Only * resource properties explicitly defined in the stack template are checked for * drift. A stack is considered to have drifted if one or more of its resources * differ from their expected template configurations. For more information, see Detecting * Unregulated Configuration Changes to Stacks and Resources.

Use * DetectStackDrift to detect drift on all supported resources for a * given stack, or DetectStackResourceDrift to detect drift on individual * resources.

For a list of stack resources that currently support drift * detection, see Resources * that Support Drift Detection.

DetectStackDrift can take * up to several minutes, depending on the number of resources contained within the * stack. Use DescribeStackDriftDetectionStatus to monitor the progress of a * detect stack drift operation. Once the drift detection operation has completed, * use DescribeStackResourceDrifts to return drift information about the * stack and its resources.

When detecting drift on a stack, CloudFormation * doesn't detect drift on any nested stacks belonging to that stack. Perform * DetectStackDrift directly on the nested stack itself.

See * Also:

AWS * API Reference

*/ virtual Model::DetectStackDriftOutcome DetectStackDrift(const Model::DetectStackDriftRequest& request) const; /** * A Callable wrapper for DetectStackDrift that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetectStackDriftOutcomeCallable DetectStackDriftCallable(const DetectStackDriftRequestT& request) const { return SubmitCallable(&CloudFormationClient::DetectStackDrift, request); } /** * An Async wrapper for DetectStackDrift that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetectStackDriftAsync(const DetectStackDriftRequestT& request, const DetectStackDriftResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DetectStackDrift, request, handler, context); } /** *

Returns information about whether a resource's actual configuration differs, * or has drifted, from its expected configuration, as defined in the stack * template and any values specified as template parameters. This information * includes actual and expected property values for resources in which * CloudFormation detects drift. Only resource properties explicitly defined in the * stack template are checked for drift. For more information about stack and * resource drift, see Detecting * Unregulated Configuration Changes to Stacks and Resources.

Use * DetectStackResourceDrift to detect drift on individual resources, * or DetectStackDrift to detect drift on all resources in a given stack * that support drift detection.

Resources that don't currently support * drift detection can't be checked. For a list of resources that support drift * detection, see Resources * that Support Drift Detection.

See Also:

AWS * API Reference

*/ virtual Model::DetectStackResourceDriftOutcome DetectStackResourceDrift(const Model::DetectStackResourceDriftRequest& request) const; /** * A Callable wrapper for DetectStackResourceDrift that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetectStackResourceDriftOutcomeCallable DetectStackResourceDriftCallable(const DetectStackResourceDriftRequestT& request) const { return SubmitCallable(&CloudFormationClient::DetectStackResourceDrift, request); } /** * An Async wrapper for DetectStackResourceDrift that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetectStackResourceDriftAsync(const DetectStackResourceDriftRequestT& request, const DetectStackResourceDriftResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DetectStackResourceDrift, request, handler, context); } /** *

Detect drift on a stack set. When CloudFormation performs drift detection on * a stack set, it performs drift detection on the stack associated with each stack * instance in the stack set. For more information, see How * CloudFormation performs drift detection on a stack set.

* DetectStackSetDrift returns the OperationId of the * stack set drift detection operation. Use this operation id with * DescribeStackSetOperation to monitor the progress of the drift detection * operation. The drift detection operation may take some time, depending on the * number of stack instances included in the stack set, in addition to the number * of resources included in each stack.

Once the operation has completed, * use the following actions to return drift information:

  • Use * DescribeStackSet to return detailed information about the stack set, * including detailed information about the last completed drift operation * performed on the stack set. (Information about drift operations that are in * progress isn't included.)

  • Use ListStackInstances to * return a list of stack instances belonging to the stack set, including the drift * status and last drift time checked of each instance.

  • Use * DescribeStackInstance to return detailed information about a specific * stack instance, including its drift status and last drift time checked.

    *

For more information about performing a drift detection operation * on a stack set, see Detecting * unmanaged changes in stack sets.

You can only run a single drift * detection operation on a given stack set at one time.

To stop a drift * detection stack set operation, use StopStackSetOperation.

See * Also:

AWS * API Reference

*/ virtual Model::DetectStackSetDriftOutcome DetectStackSetDrift(const Model::DetectStackSetDriftRequest& request) const; /** * A Callable wrapper for DetectStackSetDrift that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetectStackSetDriftOutcomeCallable DetectStackSetDriftCallable(const DetectStackSetDriftRequestT& request) const { return SubmitCallable(&CloudFormationClient::DetectStackSetDrift, request); } /** * An Async wrapper for DetectStackSetDrift that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetectStackSetDriftAsync(const DetectStackSetDriftRequestT& request, const DetectStackSetDriftResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::DetectStackSetDrift, request, handler, context); } /** *

Returns the estimated monthly cost of a template. The return value is an * Amazon Web Services Simple Monthly Calculator URL with a query string that * describes the resources required to run the template.

See Also:

* AWS * API Reference

*/ virtual Model::EstimateTemplateCostOutcome EstimateTemplateCost(const Model::EstimateTemplateCostRequest& request) const; /** * A Callable wrapper for EstimateTemplateCost that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EstimateTemplateCostOutcomeCallable EstimateTemplateCostCallable(const EstimateTemplateCostRequestT& request) const { return SubmitCallable(&CloudFormationClient::EstimateTemplateCost, request); } /** * An Async wrapper for EstimateTemplateCost that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EstimateTemplateCostAsync(const EstimateTemplateCostRequestT& request, const EstimateTemplateCostResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::EstimateTemplateCost, request, handler, context); } /** *

Updates a stack using the input information that was provided when the * specified change set was created. After the call successfully completes, * CloudFormation starts updating the stack. Use the DescribeStacks action * to view the status of the update.

When you execute a change set, * CloudFormation deletes all other change sets associated with the stack because * they aren't valid for the updated stack.

If a stack policy is associated * with the stack, CloudFormation enforces the policy during the update. You can't * specify a temporary stack policy that overrides the current policy.

To * create a change set for the entire stack hierarchy, * IncludeNestedStacks must have been set to * True.

See Also:

AWS * API Reference

*/ virtual Model::ExecuteChangeSetOutcome ExecuteChangeSet(const Model::ExecuteChangeSetRequest& request) const; /** * A Callable wrapper for ExecuteChangeSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExecuteChangeSetOutcomeCallable ExecuteChangeSetCallable(const ExecuteChangeSetRequestT& request) const { return SubmitCallable(&CloudFormationClient::ExecuteChangeSet, request); } /** * An Async wrapper for ExecuteChangeSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExecuteChangeSetAsync(const ExecuteChangeSetRequestT& request, const ExecuteChangeSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ExecuteChangeSet, request, handler, context); } /** *

Returns the stack policy for a specified stack. If a stack doesn't have a * policy, a null value is returned.

See Also:

AWS * API Reference

*/ virtual Model::GetStackPolicyOutcome GetStackPolicy(const Model::GetStackPolicyRequest& request) const; /** * A Callable wrapper for GetStackPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetStackPolicyOutcomeCallable GetStackPolicyCallable(const GetStackPolicyRequestT& request) const { return SubmitCallable(&CloudFormationClient::GetStackPolicy, request); } /** * An Async wrapper for GetStackPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetStackPolicyAsync(const GetStackPolicyRequestT& request, const GetStackPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::GetStackPolicy, request, handler, context); } /** *

Returns the template body for a specified stack. You can get the template for * running or deleted stacks.

For deleted stacks, GetTemplate * returns the template for up to 90 days after the stack has been deleted.

*

If the template doesn't exist, a ValidationError is * returned.

See Also:

AWS * API Reference

*/ virtual Model::GetTemplateOutcome GetTemplate(const Model::GetTemplateRequest& request) const; /** * A Callable wrapper for GetTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTemplateOutcomeCallable GetTemplateCallable(const GetTemplateRequestT& request) const { return SubmitCallable(&CloudFormationClient::GetTemplate, request); } /** * An Async wrapper for GetTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTemplateAsync(const GetTemplateRequestT& request, const GetTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::GetTemplate, request, handler, context); } /** *

Returns information about a new or existing template. The * GetTemplateSummary action is useful for viewing parameter * information, such as default parameter values and parameter types, before you * create or update a stack or stack set.

You can use the * GetTemplateSummary action when you submit a template, or you can * get template information for a stack set, or a running or deleted stack.

*

For deleted stacks, GetTemplateSummary returns the template * information for up to 90 days after the stack has been deleted. If the template * doesn't exist, a ValidationError is returned.

See * Also:

AWS * API Reference

*/ virtual Model::GetTemplateSummaryOutcome GetTemplateSummary(const Model::GetTemplateSummaryRequest& request) const; /** * A Callable wrapper for GetTemplateSummary that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTemplateSummaryOutcomeCallable GetTemplateSummaryCallable(const GetTemplateSummaryRequestT& request) const { return SubmitCallable(&CloudFormationClient::GetTemplateSummary, request); } /** * An Async wrapper for GetTemplateSummary that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTemplateSummaryAsync(const GetTemplateSummaryRequestT& request, const GetTemplateSummaryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::GetTemplateSummary, request, handler, context); } /** *

Import existing stacks into a new stack sets. Use the stack import operation * to import up to 10 stacks into a new stack set in the same account as the source * stack or in a different administrator account and Region, by specifying the * stack ID of the stack you intend to import.

See Also:

AWS * API Reference

*/ virtual Model::ImportStacksToStackSetOutcome ImportStacksToStackSet(const Model::ImportStacksToStackSetRequest& request) const; /** * A Callable wrapper for ImportStacksToStackSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportStacksToStackSetOutcomeCallable ImportStacksToStackSetCallable(const ImportStacksToStackSetRequestT& request) const { return SubmitCallable(&CloudFormationClient::ImportStacksToStackSet, request); } /** * An Async wrapper for ImportStacksToStackSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportStacksToStackSetAsync(const ImportStacksToStackSetRequestT& request, const ImportStacksToStackSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ImportStacksToStackSet, request, handler, context); } /** *

Returns the ID and status of each active change set for a stack. For example, * CloudFormation lists change sets that are in the CREATE_IN_PROGRESS * or CREATE_PENDING state.

See Also:

AWS * API Reference

*/ virtual Model::ListChangeSetsOutcome ListChangeSets(const Model::ListChangeSetsRequest& request) const; /** * A Callable wrapper for ListChangeSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChangeSetsOutcomeCallable ListChangeSetsCallable(const ListChangeSetsRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListChangeSets, request); } /** * An Async wrapper for ListChangeSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChangeSetsAsync(const ListChangeSetsRequestT& request, const ListChangeSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListChangeSets, request, handler, context); } /** *

Lists all exported output values in the account and Region in which you call * this action. Use this action to see the exported output values that you can * import into other stacks. To import values, use the * Fn::ImportValue function.

For more information, see * CloudFormation export stack output values.

See Also:

AWS * API Reference

*/ virtual Model::ListExportsOutcome ListExports(const Model::ListExportsRequest& request) const; /** * A Callable wrapper for ListExports that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListExportsOutcomeCallable ListExportsCallable(const ListExportsRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListExports, request); } /** * An Async wrapper for ListExports that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListExportsAsync(const ListExportsRequestT& request, const ListExportsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListExports, request, handler, context); } /** *

Lists all stacks that are importing an exported output value. To modify or * remove an exported output value, first use this action to see which stacks are * using it. To see the exported output values in your account, see * ListExports.

For more information about importing an exported * output value, see the Fn::ImportValue * function.

See Also:

AWS * API Reference

*/ virtual Model::ListImportsOutcome ListImports(const Model::ListImportsRequest& request) const; /** * A Callable wrapper for ListImports that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListImportsOutcomeCallable ListImportsCallable(const ListImportsRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListImports, request); } /** * An Async wrapper for ListImports that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListImportsAsync(const ListImportsRequestT& request, const ListImportsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListImports, request, handler, context); } /** *

Returns drift information for resources in a stack instance.

* ListStackInstanceResourceDrifts returns drift information for the * most recent drift detection operation. If an operation is in progress, it may * only return partial results.

See Also:

AWS * API Reference

*/ virtual Model::ListStackInstanceResourceDriftsOutcome ListStackInstanceResourceDrifts(const Model::ListStackInstanceResourceDriftsRequest& request) const; /** * A Callable wrapper for ListStackInstanceResourceDrifts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStackInstanceResourceDriftsOutcomeCallable ListStackInstanceResourceDriftsCallable(const ListStackInstanceResourceDriftsRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListStackInstanceResourceDrifts, request); } /** * An Async wrapper for ListStackInstanceResourceDrifts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStackInstanceResourceDriftsAsync(const ListStackInstanceResourceDriftsRequestT& request, const ListStackInstanceResourceDriftsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListStackInstanceResourceDrifts, request, handler, context); } /** *

Returns summary information about stack instances that are associated with * the specified stack set. You can filter for stack instances that are associated * with a specific Amazon Web Services account name or Region, or that have a * specific status.

See Also:

AWS * API Reference

*/ virtual Model::ListStackInstancesOutcome ListStackInstances(const Model::ListStackInstancesRequest& request) const; /** * A Callable wrapper for ListStackInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStackInstancesOutcomeCallable ListStackInstancesCallable(const ListStackInstancesRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListStackInstances, request); } /** * An Async wrapper for ListStackInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStackInstancesAsync(const ListStackInstancesRequestT& request, const ListStackInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListStackInstances, request, handler, context); } /** *

Returns descriptions of all resources of the specified stack.

For * deleted stacks, ListStackResources returns resource information for up to 90 * days after the stack has been deleted.

See Also:

AWS * API Reference

*/ virtual Model::ListStackResourcesOutcome ListStackResources(const Model::ListStackResourcesRequest& request) const; /** * A Callable wrapper for ListStackResources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStackResourcesOutcomeCallable ListStackResourcesCallable(const ListStackResourcesRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListStackResources, request); } /** * An Async wrapper for ListStackResources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStackResourcesAsync(const ListStackResourcesRequestT& request, const ListStackResourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListStackResources, request, handler, context); } /** *

Returns summary information about the results of a stack set * operation.

See Also:

AWS * API Reference

*/ virtual Model::ListStackSetOperationResultsOutcome ListStackSetOperationResults(const Model::ListStackSetOperationResultsRequest& request) const; /** * A Callable wrapper for ListStackSetOperationResults that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStackSetOperationResultsOutcomeCallable ListStackSetOperationResultsCallable(const ListStackSetOperationResultsRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListStackSetOperationResults, request); } /** * An Async wrapper for ListStackSetOperationResults that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStackSetOperationResultsAsync(const ListStackSetOperationResultsRequestT& request, const ListStackSetOperationResultsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListStackSetOperationResults, request, handler, context); } /** *

Returns summary information about operations performed on a stack * set.

See Also:

AWS * API Reference

*/ virtual Model::ListStackSetOperationsOutcome ListStackSetOperations(const Model::ListStackSetOperationsRequest& request) const; /** * A Callable wrapper for ListStackSetOperations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStackSetOperationsOutcomeCallable ListStackSetOperationsCallable(const ListStackSetOperationsRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListStackSetOperations, request); } /** * An Async wrapper for ListStackSetOperations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStackSetOperationsAsync(const ListStackSetOperationsRequestT& request, const ListStackSetOperationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListStackSetOperations, request, handler, context); } /** *

Returns summary information about stack sets that are associated with the * user.

  • [Self-managed permissions] If you set the * CallAs parameter to SELF while signed in to your * Amazon Web Services account, ListStackSets returns all self-managed * stack sets in your Amazon Web Services account.

  • *

    [Service-managed permissions] If you set the CallAs parameter to * SELF while signed in to the organization's management account, * ListStackSets returns all stack sets in the management account.

    *

  • [Service-managed permissions] If you set the CallAs * parameter to DELEGATED_ADMIN while signed in to your member * account, ListStackSets returns all stack sets with service-managed * permissions in the management account.

See Also:

AWS * API Reference

*/ virtual Model::ListStackSetsOutcome ListStackSets(const Model::ListStackSetsRequest& request) const; /** * A Callable wrapper for ListStackSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStackSetsOutcomeCallable ListStackSetsCallable(const ListStackSetsRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListStackSets, request); } /** * An Async wrapper for ListStackSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStackSetsAsync(const ListStackSetsRequestT& request, const ListStackSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListStackSets, request, handler, context); } /** *

Returns the summary information for stacks whose status matches the specified * StackStatusFilter. Summary information for stacks that have been deleted is kept * for 90 days after the stack is deleted. If no StackStatusFilter is specified, * summary information for all stacks is returned (including existing stacks and * stacks that have been deleted).

See Also:

AWS * API Reference

*/ virtual Model::ListStacksOutcome ListStacks(const Model::ListStacksRequest& request) const; /** * A Callable wrapper for ListStacks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStacksOutcomeCallable ListStacksCallable(const ListStacksRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListStacks, request); } /** * An Async wrapper for ListStacks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStacksAsync(const ListStacksRequestT& request, const ListStacksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListStacks, request, handler, context); } /** *

Returns a list of registration tokens for the specified * extension(s).

See Also:

AWS * API Reference

*/ virtual Model::ListTypeRegistrationsOutcome ListTypeRegistrations(const Model::ListTypeRegistrationsRequest& request) const; /** * A Callable wrapper for ListTypeRegistrations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTypeRegistrationsOutcomeCallable ListTypeRegistrationsCallable(const ListTypeRegistrationsRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListTypeRegistrations, request); } /** * An Async wrapper for ListTypeRegistrations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTypeRegistrationsAsync(const ListTypeRegistrationsRequestT& request, const ListTypeRegistrationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListTypeRegistrations, request, handler, context); } /** *

Returns summary information about the versions of an extension.

See * Also:

AWS * API Reference

*/ virtual Model::ListTypeVersionsOutcome ListTypeVersions(const Model::ListTypeVersionsRequest& request) const; /** * A Callable wrapper for ListTypeVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTypeVersionsOutcomeCallable ListTypeVersionsCallable(const ListTypeVersionsRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListTypeVersions, request); } /** * An Async wrapper for ListTypeVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTypeVersionsAsync(const ListTypeVersionsRequestT& request, const ListTypeVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListTypeVersions, request, handler, context); } /** *

Returns summary information about extension that have been registered with * CloudFormation.

See Also:

AWS * API Reference

*/ virtual Model::ListTypesOutcome ListTypes(const Model::ListTypesRequest& request) const; /** * A Callable wrapper for ListTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTypesOutcomeCallable ListTypesCallable(const ListTypesRequestT& request) const { return SubmitCallable(&CloudFormationClient::ListTypes, request); } /** * An Async wrapper for ListTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTypesAsync(const ListTypesRequestT& request, const ListTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ListTypes, request, handler, context); } /** *

Publishes the specified extension to the CloudFormation registry as a public * extension in this Region. Public extensions are available for use by all * CloudFormation users. For more information about publishing extensions, see Publishing * extensions to make them available for public use in the CloudFormation * CLI User Guide.

To publish an extension, you must be registered as a * publisher with CloudFormation. For more information, see RegisterPublisher.

See * Also:

AWS * API Reference

*/ virtual Model::PublishTypeOutcome PublishType(const Model::PublishTypeRequest& request) const; /** * A Callable wrapper for PublishType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PublishTypeOutcomeCallable PublishTypeCallable(const PublishTypeRequestT& request) const { return SubmitCallable(&CloudFormationClient::PublishType, request); } /** * An Async wrapper for PublishType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PublishTypeAsync(const PublishTypeRequestT& request, const PublishTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::PublishType, request, handler, context); } /** *

Reports progress of a resource handler to CloudFormation.

Reserved for * use by the CloudFormation * CLI. Don't use this API in your code.

See Also:

AWS * API Reference

*/ virtual Model::RecordHandlerProgressOutcome RecordHandlerProgress(const Model::RecordHandlerProgressRequest& request) const; /** * A Callable wrapper for RecordHandlerProgress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RecordHandlerProgressOutcomeCallable RecordHandlerProgressCallable(const RecordHandlerProgressRequestT& request) const { return SubmitCallable(&CloudFormationClient::RecordHandlerProgress, request); } /** * An Async wrapper for RecordHandlerProgress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RecordHandlerProgressAsync(const RecordHandlerProgressRequestT& request, const RecordHandlerProgressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::RecordHandlerProgress, request, handler, context); } /** *

Registers your account as a publisher of public extensions in the * CloudFormation registry. Public extensions are available for use by all * CloudFormation users. This publisher ID applies to your account in all Amazon * Web Services Regions.

For information about requirements for registering * as a public extension publisher, see Registering * your account to publish CloudFormation extensions in the CloudFormation * CLI User Guide.

See Also:

AWS * API Reference

*/ virtual Model::RegisterPublisherOutcome RegisterPublisher(const Model::RegisterPublisherRequest& request) const; /** * A Callable wrapper for RegisterPublisher that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterPublisherOutcomeCallable RegisterPublisherCallable(const RegisterPublisherRequestT& request) const { return SubmitCallable(&CloudFormationClient::RegisterPublisher, request); } /** * An Async wrapper for RegisterPublisher that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterPublisherAsync(const RegisterPublisherRequestT& request, const RegisterPublisherResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::RegisterPublisher, request, handler, context); } /** *

Registers an extension with the CloudFormation service. Registering an * extension makes it available for use in CloudFormation templates in your Amazon * Web Services account, and includes:

  • Validating the extension * schema.

  • Determining which handlers, if any, have been * specified for the extension.

  • Making the extension available * for use in your account.

For more information about how to * develop extensions and ready them for registration, see Creating * Resource Providers in the CloudFormation CLI User Guide.

You * can have a maximum of 50 resource extension versions registered at a time. This * maximum is per account and per Region. Use DeregisterType * to deregister specific extension versions if necessary.

Once you have * initiated a registration request using RegisterType, you can use * DescribeTypeRegistration to monitor the progress of the registration * request.

Once you have registered a private extension in your account and * Region, use SetTypeConfiguration * to specify configuration properties for the extension. For more information, see * Configuring * extensions at the account level in the CloudFormation User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::RegisterTypeOutcome RegisterType(const Model::RegisterTypeRequest& request) const; /** * A Callable wrapper for RegisterType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterTypeOutcomeCallable RegisterTypeCallable(const RegisterTypeRequestT& request) const { return SubmitCallable(&CloudFormationClient::RegisterType, request); } /** * An Async wrapper for RegisterType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterTypeAsync(const RegisterTypeRequestT& request, const RegisterTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::RegisterType, request, handler, context); } /** *

When specifying RollbackStack, you preserve the state of * previously provisioned resources when an operation fails. You can check the * status of the stack through the DescribeStacks operation.

Rolls * back the specified stack to the last known stable state from * CREATE_FAILED or UPDATE_FAILED stack statuses.

*

This operation will delete a stack if it doesn't contain a last known stable * state. A last known stable state includes any status in a * *_COMPLETE. This includes the following stack statuses.

    *

  • CREATE_COMPLETE

  • * UPDATE_COMPLETE

  • * UPDATE_ROLLBACK_COMPLETE

  • * IMPORT_COMPLETE

  • * IMPORT_ROLLBACK_COMPLETE

See Also:

AWS * API Reference

*/ virtual Model::RollbackStackOutcome RollbackStack(const Model::RollbackStackRequest& request) const; /** * A Callable wrapper for RollbackStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RollbackStackOutcomeCallable RollbackStackCallable(const RollbackStackRequestT& request) const { return SubmitCallable(&CloudFormationClient::RollbackStack, request); } /** * An Async wrapper for RollbackStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RollbackStackAsync(const RollbackStackRequestT& request, const RollbackStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::RollbackStack, request, handler, context); } /** *

Sets a stack policy for a specified stack.

See Also:

AWS * API Reference

*/ virtual Model::SetStackPolicyOutcome SetStackPolicy(const Model::SetStackPolicyRequest& request) const; /** * A Callable wrapper for SetStackPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetStackPolicyOutcomeCallable SetStackPolicyCallable(const SetStackPolicyRequestT& request) const { return SubmitCallable(&CloudFormationClient::SetStackPolicy, request); } /** * An Async wrapper for SetStackPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetStackPolicyAsync(const SetStackPolicyRequestT& request, const SetStackPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::SetStackPolicy, request, handler, context); } /** *

Specifies the configuration data for a registered CloudFormation extension, * in the given account and Region.

To view the current configuration data * for an extension, refer to the ConfigurationSchema element of DescribeType. * For more information, see Configuring * extensions at the account level in the CloudFormation User Guide.

*

It's strongly recommended that you use dynamic references to * restrict sensitive configuration definitions, such as third-party credentials. * For more details on dynamic references, see Using dynamic references to specify template * values in the CloudFormation User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::SetTypeConfigurationOutcome SetTypeConfiguration(const Model::SetTypeConfigurationRequest& request) const; /** * A Callable wrapper for SetTypeConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetTypeConfigurationOutcomeCallable SetTypeConfigurationCallable(const SetTypeConfigurationRequestT& request) const { return SubmitCallable(&CloudFormationClient::SetTypeConfiguration, request); } /** * An Async wrapper for SetTypeConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetTypeConfigurationAsync(const SetTypeConfigurationRequestT& request, const SetTypeConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::SetTypeConfiguration, request, handler, context); } /** *

Specify the default version of an extension. The default version of an * extension will be used in CloudFormation operations.

See Also:

* AWS * API Reference

*/ virtual Model::SetTypeDefaultVersionOutcome SetTypeDefaultVersion(const Model::SetTypeDefaultVersionRequest& request) const; /** * A Callable wrapper for SetTypeDefaultVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetTypeDefaultVersionOutcomeCallable SetTypeDefaultVersionCallable(const SetTypeDefaultVersionRequestT& request) const { return SubmitCallable(&CloudFormationClient::SetTypeDefaultVersion, request); } /** * An Async wrapper for SetTypeDefaultVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetTypeDefaultVersionAsync(const SetTypeDefaultVersionRequestT& request, const SetTypeDefaultVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::SetTypeDefaultVersion, request, handler, context); } /** *

Sends a signal to the specified resource with a success or failure status. * You can use the SignalResource operation in conjunction with a * creation policy or update policy. CloudFormation doesn't proceed with a stack * creation or update until resources receive the required number of signals or the * timeout period is exceeded. The SignalResource operation is useful * in cases where you want to send signals from anywhere other than an Amazon EC2 * instance.

See Also:

AWS * API Reference

*/ virtual Model::SignalResourceOutcome SignalResource(const Model::SignalResourceRequest& request) const; /** * A Callable wrapper for SignalResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SignalResourceOutcomeCallable SignalResourceCallable(const SignalResourceRequestT& request) const { return SubmitCallable(&CloudFormationClient::SignalResource, request); } /** * An Async wrapper for SignalResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SignalResourceAsync(const SignalResourceRequestT& request, const SignalResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::SignalResource, request, handler, context); } /** *

Stops an in-progress operation on a stack set and its associated stack * instances. StackSets will cancel all the unstarted stack instance deployments * and wait for those are in-progress to complete.

See Also:

AWS * API Reference

*/ virtual Model::StopStackSetOperationOutcome StopStackSetOperation(const Model::StopStackSetOperationRequest& request) const; /** * A Callable wrapper for StopStackSetOperation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopStackSetOperationOutcomeCallable StopStackSetOperationCallable(const StopStackSetOperationRequestT& request) const { return SubmitCallable(&CloudFormationClient::StopStackSetOperation, request); } /** * An Async wrapper for StopStackSetOperation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopStackSetOperationAsync(const StopStackSetOperationRequestT& request, const StopStackSetOperationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::StopStackSetOperation, request, handler, context); } /** *

Tests a registered extension to make sure it meets all necessary requirements * for being published in the CloudFormation registry.

  • For * resource types, this includes passing all contracts tests defined for the * type.

  • For modules, this includes determining if the module's * model meets all necessary requirements.

For more information, * see Testing * your public extension prior to publishing in the CloudFormation CLI User * Guide.

If you don't specify a version, CloudFormation uses the * default version of the extension in your account and Region for testing.

*

To perform testing, CloudFormation assumes the execution role specified when * the type was registered. For more information, see RegisterType.

*

Once you've initiated testing on an extension using TestType, * you can pass the returned TypeVersionArn into DescribeType * to monitor the current test status and test status description for the * extension.

An extension must have a test status of PASSED * before it can be published. For more information, see Publishing * extensions to make them available for public use in the CloudFormation * CLI User Guide.

See Also:

AWS * API Reference

*/ virtual Model::TestTypeOutcome TestType(const Model::TestTypeRequest& request) const; /** * A Callable wrapper for TestType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TestTypeOutcomeCallable TestTypeCallable(const TestTypeRequestT& request) const { return SubmitCallable(&CloudFormationClient::TestType, request); } /** * An Async wrapper for TestType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TestTypeAsync(const TestTypeRequestT& request, const TestTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::TestType, request, handler, context); } /** *

Updates a stack as specified in the template. After the call completes * successfully, the stack update starts. You can check the status of the stack * through the DescribeStacks action.

To get a copy of the template * for an existing stack, you can use the GetTemplate action.

For * more information about creating an update template, updating a stack, and * monitoring the progress of the update, see Updating * a Stack.

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(&CloudFormationClient::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(&CloudFormationClient::UpdateStack, request, handler, context); } /** *

Updates the parameter values for stack instances for the specified accounts, * within the specified Amazon Web Services Regions. A stack instance refers to a * stack in a specific account and Region.

You can only update stack * instances in Amazon Web Services Regions and accounts where they already exist; * to create additional stack instances, use CreateStackInstances.

*

During stack set updates, any parameters overridden for a stack instance * aren't updated, but retain their overridden value.

You can only update * the parameter values that are specified in the stack set; to add or * delete a parameter itself, use UpdateStackSet * to update the stack set template. If you add a parameter to a template, before * you can override the parameter value specified in the stack set you must first * use UpdateStackSet * to update all stack instances with the updated template and parameter value * specified in the stack set. Once a stack instance has been updated with the new * parameter, you can then override the parameter value using * UpdateStackInstances.

See Also:

AWS * API Reference

*/ virtual Model::UpdateStackInstancesOutcome UpdateStackInstances(const Model::UpdateStackInstancesRequest& request) const; /** * A Callable wrapper for UpdateStackInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStackInstancesOutcomeCallable UpdateStackInstancesCallable(const UpdateStackInstancesRequestT& request) const { return SubmitCallable(&CloudFormationClient::UpdateStackInstances, request); } /** * An Async wrapper for UpdateStackInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStackInstancesAsync(const UpdateStackInstancesRequestT& request, const UpdateStackInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::UpdateStackInstances, request, handler, context); } /** *

Updates the stack set, and associated stack instances in the specified * accounts and Amazon Web Services Regions.

Even if the stack set operation * created by updating the stack set fails (completely or partially, below or above * a specified failure tolerance), the stack set is updated with your changes. * Subsequent CreateStackInstances calls on the specified stack set use the * updated stack set.

See Also:

AWS * API Reference

*/ virtual Model::UpdateStackSetOutcome UpdateStackSet(const Model::UpdateStackSetRequest& request) const; /** * A Callable wrapper for UpdateStackSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStackSetOutcomeCallable UpdateStackSetCallable(const UpdateStackSetRequestT& request) const { return SubmitCallable(&CloudFormationClient::UpdateStackSet, request); } /** * An Async wrapper for UpdateStackSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStackSetAsync(const UpdateStackSetRequestT& request, const UpdateStackSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::UpdateStackSet, request, handler, context); } /** *

Updates termination protection for the specified stack. If a user attempts to * delete a stack with termination protection enabled, the operation fails and the * stack remains unchanged. For more information, see Protecting * a Stack From Being Deleted in the CloudFormation User Guide.

*

For nested * stacks, termination protection is set on the root stack and can't be changed * directly on the nested stack.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTerminationProtectionOutcome UpdateTerminationProtection(const Model::UpdateTerminationProtectionRequest& request) const; /** * A Callable wrapper for UpdateTerminationProtection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTerminationProtectionOutcomeCallable UpdateTerminationProtectionCallable(const UpdateTerminationProtectionRequestT& request) const { return SubmitCallable(&CloudFormationClient::UpdateTerminationProtection, request); } /** * An Async wrapper for UpdateTerminationProtection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTerminationProtectionAsync(const UpdateTerminationProtectionRequestT& request, const UpdateTerminationProtectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::UpdateTerminationProtection, request, handler, context); } /** *

Validates a specified template. CloudFormation first checks if the template * is valid JSON. If it isn't, CloudFormation checks if the template is valid YAML. * If both these checks fail, CloudFormation returns a template validation * error.

See Also:

AWS * API Reference

*/ virtual Model::ValidateTemplateOutcome ValidateTemplate(const Model::ValidateTemplateRequest& request) const; /** * A Callable wrapper for ValidateTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ValidateTemplateOutcomeCallable ValidateTemplateCallable(const ValidateTemplateRequestT& request) const { return SubmitCallable(&CloudFormationClient::ValidateTemplate, request); } /** * An Async wrapper for ValidateTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ValidateTemplateAsync(const ValidateTemplateRequestT& request, const ValidateTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFormationClient::ValidateTemplate, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const CloudFormationClientConfiguration& clientConfiguration); CloudFormationClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace CloudFormation } // namespace Aws