Lesson 35 - Get Compute Auth Token Working
This commit is contained in:
Norman Lansing
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/client/GenericClientConfiguration.h>
|
||||
#include <aws/core/endpoint/DefaultEndpointProvider.h>
|
||||
#include <aws/core/endpoint/EndpointParameter.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
|
||||
#include <aws/cloudformation/CloudFormationEndpointRules.h>
|
||||
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Endpoint
|
||||
{
|
||||
using EndpointParameters = Aws::Endpoint::EndpointParameters;
|
||||
using Aws::Endpoint::EndpointProviderBase;
|
||||
using Aws::Endpoint::DefaultEndpointProvider;
|
||||
|
||||
using CloudFormationClientContextParameters = Aws::Endpoint::ClientContextParameters;
|
||||
|
||||
using CloudFormationClientConfiguration = Aws::Client::GenericClientConfiguration;
|
||||
using CloudFormationBuiltInParameters = Aws::Endpoint::BuiltInParameters;
|
||||
|
||||
/**
|
||||
* The type for the CloudFormation Client Endpoint Provider.
|
||||
* Inherit from this Base class / "Interface" should you want to provide a custom endpoint provider.
|
||||
* The SDK must use service-specific type for each service per specification.
|
||||
*/
|
||||
using CloudFormationEndpointProviderBase =
|
||||
EndpointProviderBase<CloudFormationClientConfiguration, CloudFormationBuiltInParameters, CloudFormationClientContextParameters>;
|
||||
|
||||
using CloudFormationDefaultEpProviderBase =
|
||||
DefaultEndpointProvider<CloudFormationClientConfiguration, CloudFormationBuiltInParameters, CloudFormationClientContextParameters>;
|
||||
|
||||
/**
|
||||
* Default endpoint provider used for this service
|
||||
*/
|
||||
class AWS_CLOUDFORMATION_API CloudFormationEndpointProvider : public CloudFormationDefaultEpProviderBase
|
||||
{
|
||||
public:
|
||||
using CloudFormationResolveEndpointOutcome = Aws::Endpoint::ResolveEndpointOutcome;
|
||||
|
||||
CloudFormationEndpointProvider()
|
||||
: CloudFormationDefaultEpProviderBase(Aws::CloudFormation::CloudFormationEndpointRules::GetRulesBlob(), Aws::CloudFormation::CloudFormationEndpointRules::RulesBlobSize)
|
||||
{}
|
||||
|
||||
~CloudFormationEndpointProvider()
|
||||
{
|
||||
}
|
||||
};
|
||||
} // namespace Endpoint
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,23 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <cstddef>
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
class CloudFormationEndpointRules
|
||||
{
|
||||
public:
|
||||
static const size_t RulesBlobStrLen;
|
||||
static const size_t RulesBlobSize;
|
||||
|
||||
static const char* GetRulesBlob();
|
||||
};
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,23 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/client/AWSErrorMarshaller.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Client
|
||||
{
|
||||
|
||||
class AWS_CLOUDFORMATION_API CloudFormationErrorMarshaller : public Aws::Client::XmlErrorMarshaller
|
||||
{
|
||||
public:
|
||||
Aws::Client::AWSError<Aws::Client::CoreErrors> FindErrorByName(const char* exceptionName) const override;
|
||||
};
|
||||
|
||||
} // namespace Client
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <aws/core/client/AWSError.h>
|
||||
#include <aws/core/client/CoreErrors.h>
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
enum class CloudFormationErrors
|
||||
{
|
||||
//From Core//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
INCOMPLETE_SIGNATURE = 0,
|
||||
INTERNAL_FAILURE = 1,
|
||||
INVALID_ACTION = 2,
|
||||
INVALID_CLIENT_TOKEN_ID = 3,
|
||||
INVALID_PARAMETER_COMBINATION = 4,
|
||||
INVALID_QUERY_PARAMETER = 5,
|
||||
INVALID_PARAMETER_VALUE = 6,
|
||||
MISSING_ACTION = 7, // SDK should never allow
|
||||
MISSING_AUTHENTICATION_TOKEN = 8, // SDK should never allow
|
||||
MISSING_PARAMETER = 9, // SDK should never allow
|
||||
OPT_IN_REQUIRED = 10,
|
||||
REQUEST_EXPIRED = 11,
|
||||
SERVICE_UNAVAILABLE = 12,
|
||||
THROTTLING = 13,
|
||||
VALIDATION = 14,
|
||||
ACCESS_DENIED = 15,
|
||||
RESOURCE_NOT_FOUND = 16,
|
||||
UNRECOGNIZED_CLIENT = 17,
|
||||
MALFORMED_QUERY_STRING = 18,
|
||||
SLOW_DOWN = 19,
|
||||
REQUEST_TIME_TOO_SKEWED = 20,
|
||||
INVALID_SIGNATURE = 21,
|
||||
SIGNATURE_DOES_NOT_MATCH = 22,
|
||||
INVALID_ACCESS_KEY_ID = 23,
|
||||
REQUEST_TIMEOUT = 24,
|
||||
NETWORK_CONNECTION = 99,
|
||||
|
||||
UNKNOWN = 100,
|
||||
///////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
ALREADY_EXISTS= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
|
||||
CHANGE_SET_NOT_FOUND,
|
||||
CONCURRENT_RESOURCES_LIMIT_EXCEEDED,
|
||||
CREATED_BUT_MODIFIED,
|
||||
C_F_N_REGISTRY,
|
||||
GENERATED_TEMPLATE_NOT_FOUND,
|
||||
INSUFFICIENT_CAPABILITIES,
|
||||
INVALID_CHANGE_SET_STATUS,
|
||||
INVALID_OPERATION,
|
||||
INVALID_STATE_TRANSITION,
|
||||
LIMIT_EXCEEDED,
|
||||
NAME_ALREADY_EXISTS,
|
||||
OPERATION_ID_ALREADY_EXISTS,
|
||||
OPERATION_IN_PROGRESS,
|
||||
OPERATION_NOT_FOUND,
|
||||
OPERATION_STATUS_CHECK_FAILED,
|
||||
RESOURCE_SCAN_IN_PROGRESS,
|
||||
RESOURCE_SCAN_LIMIT_EXCEEDED,
|
||||
RESOURCE_SCAN_NOT_FOUND,
|
||||
STACK_INSTANCE_NOT_FOUND,
|
||||
STACK_NOT_FOUND,
|
||||
STACK_SET_NOT_EMPTY,
|
||||
STACK_SET_NOT_FOUND,
|
||||
STALE_REQUEST,
|
||||
TOKEN_ALREADY_EXISTS,
|
||||
TYPE_CONFIGURATION_NOT_FOUND,
|
||||
TYPE_NOT_FOUND
|
||||
};
|
||||
|
||||
class AWS_CLOUDFORMATION_API CloudFormationError : public Aws::Client::AWSError<CloudFormationErrors>
|
||||
{
|
||||
public:
|
||||
CloudFormationError() {}
|
||||
CloudFormationError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<CloudFormationErrors>(rhs) {}
|
||||
CloudFormationError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<CloudFormationErrors>(rhs) {}
|
||||
CloudFormationError(const Aws::Client::AWSError<CloudFormationErrors>& rhs) : Aws::Client::AWSError<CloudFormationErrors>(rhs) {}
|
||||
CloudFormationError(Aws::Client::AWSError<CloudFormationErrors>&& rhs) : Aws::Client::AWSError<CloudFormationErrors>(rhs) {}
|
||||
|
||||
template <typename T>
|
||||
T GetModeledError();
|
||||
};
|
||||
|
||||
namespace CloudFormationErrorMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
|
||||
}
|
||||
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,46 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/endpoint/AWSEndpoint.h>
|
||||
#include <aws/core/AmazonSerializableWebServiceRequest.h>
|
||||
#include <aws/core/utils/UnreferencedParam.h>
|
||||
#include <aws/core/http/HttpRequest.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
class AWS_CLOUDFORMATION_API CloudFormationRequest : public Aws::AmazonSerializableWebServiceRequest
|
||||
{
|
||||
public:
|
||||
using EndpointParameter = Aws::Endpoint::EndpointParameter;
|
||||
using EndpointParameters = Aws::Endpoint::EndpointParameters;
|
||||
|
||||
virtual ~CloudFormationRequest () {}
|
||||
|
||||
void AddParametersToRequest(Aws::Http::HttpRequest& httpRequest) const { AWS_UNREFERENCED_PARAM(httpRequest); }
|
||||
|
||||
inline Aws::Http::HeaderValueCollection GetHeaders() const override
|
||||
{
|
||||
auto headers = GetRequestSpecificHeaders();
|
||||
|
||||
if(headers.size() == 0 || (headers.size() > 0 && headers.count(Aws::Http::CONTENT_TYPE_HEADER) == 0))
|
||||
{
|
||||
headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::CONTENT_TYPE_HEADER, Aws::FORM_CONTENT_TYPE ));
|
||||
}
|
||||
headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2010-05-15"));
|
||||
return headers;
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
|
||||
|
||||
};
|
||||
|
||||
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,510 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
/* Generic header includes */
|
||||
#include <aws/cloudformation/CloudFormationErrors.h>
|
||||
#include <aws/core/client/GenericClientConfiguration.h>
|
||||
#include <aws/core/client/AWSError.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/client/AsyncCallerContext.h>
|
||||
#include <aws/core/http/HttpTypes.h>
|
||||
#include <aws/cloudformation/CloudFormationEndpointProvider.h>
|
||||
#include <future>
|
||||
#include <functional>
|
||||
/* End of generic header includes */
|
||||
|
||||
/* Service model headers required in CloudFormationClient header */
|
||||
#include <aws/cloudformation/model/ActivateOrganizationsAccessResult.h>
|
||||
#include <aws/cloudformation/model/ActivateTypeResult.h>
|
||||
#include <aws/cloudformation/model/BatchDescribeTypeConfigurationsResult.h>
|
||||
#include <aws/cloudformation/model/ContinueUpdateRollbackResult.h>
|
||||
#include <aws/cloudformation/model/CreateChangeSetResult.h>
|
||||
#include <aws/cloudformation/model/CreateGeneratedTemplateResult.h>
|
||||
#include <aws/cloudformation/model/CreateStackResult.h>
|
||||
#include <aws/cloudformation/model/CreateStackInstancesResult.h>
|
||||
#include <aws/cloudformation/model/CreateStackSetResult.h>
|
||||
#include <aws/cloudformation/model/DeactivateOrganizationsAccessResult.h>
|
||||
#include <aws/cloudformation/model/DeactivateTypeResult.h>
|
||||
#include <aws/cloudformation/model/DeleteChangeSetResult.h>
|
||||
#include <aws/cloudformation/model/DeleteStackInstancesResult.h>
|
||||
#include <aws/cloudformation/model/DeleteStackSetResult.h>
|
||||
#include <aws/cloudformation/model/DeregisterTypeResult.h>
|
||||
#include <aws/cloudformation/model/DescribeAccountLimitsResult.h>
|
||||
#include <aws/cloudformation/model/DescribeChangeSetResult.h>
|
||||
#include <aws/cloudformation/model/DescribeChangeSetHooksResult.h>
|
||||
#include <aws/cloudformation/model/DescribeGeneratedTemplateResult.h>
|
||||
#include <aws/cloudformation/model/DescribeOrganizationsAccessResult.h>
|
||||
#include <aws/cloudformation/model/DescribePublisherResult.h>
|
||||
#include <aws/cloudformation/model/DescribeResourceScanResult.h>
|
||||
#include <aws/cloudformation/model/DescribeStackDriftDetectionStatusResult.h>
|
||||
#include <aws/cloudformation/model/DescribeStackEventsResult.h>
|
||||
#include <aws/cloudformation/model/DescribeStackInstanceResult.h>
|
||||
#include <aws/cloudformation/model/DescribeStackResourceResult.h>
|
||||
#include <aws/cloudformation/model/DescribeStackResourceDriftsResult.h>
|
||||
#include <aws/cloudformation/model/DescribeStackResourcesResult.h>
|
||||
#include <aws/cloudformation/model/DescribeStackSetResult.h>
|
||||
#include <aws/cloudformation/model/DescribeStackSetOperationResult.h>
|
||||
#include <aws/cloudformation/model/DescribeStacksResult.h>
|
||||
#include <aws/cloudformation/model/DescribeTypeResult.h>
|
||||
#include <aws/cloudformation/model/DescribeTypeRegistrationResult.h>
|
||||
#include <aws/cloudformation/model/DetectStackDriftResult.h>
|
||||
#include <aws/cloudformation/model/DetectStackResourceDriftResult.h>
|
||||
#include <aws/cloudformation/model/DetectStackSetDriftResult.h>
|
||||
#include <aws/cloudformation/model/EstimateTemplateCostResult.h>
|
||||
#include <aws/cloudformation/model/ExecuteChangeSetResult.h>
|
||||
#include <aws/cloudformation/model/GetGeneratedTemplateResult.h>
|
||||
#include <aws/cloudformation/model/GetStackPolicyResult.h>
|
||||
#include <aws/cloudformation/model/GetTemplateResult.h>
|
||||
#include <aws/cloudformation/model/GetTemplateSummaryResult.h>
|
||||
#include <aws/cloudformation/model/ImportStacksToStackSetResult.h>
|
||||
#include <aws/cloudformation/model/ListChangeSetsResult.h>
|
||||
#include <aws/cloudformation/model/ListExportsResult.h>
|
||||
#include <aws/cloudformation/model/ListGeneratedTemplatesResult.h>
|
||||
#include <aws/cloudformation/model/ListImportsResult.h>
|
||||
#include <aws/cloudformation/model/ListResourceScanRelatedResourcesResult.h>
|
||||
#include <aws/cloudformation/model/ListResourceScanResourcesResult.h>
|
||||
#include <aws/cloudformation/model/ListResourceScansResult.h>
|
||||
#include <aws/cloudformation/model/ListStackInstanceResourceDriftsResult.h>
|
||||
#include <aws/cloudformation/model/ListStackInstancesResult.h>
|
||||
#include <aws/cloudformation/model/ListStackResourcesResult.h>
|
||||
#include <aws/cloudformation/model/ListStackSetAutoDeploymentTargetsResult.h>
|
||||
#include <aws/cloudformation/model/ListStackSetOperationResultsResult.h>
|
||||
#include <aws/cloudformation/model/ListStackSetOperationsResult.h>
|
||||
#include <aws/cloudformation/model/ListStackSetsResult.h>
|
||||
#include <aws/cloudformation/model/ListStacksResult.h>
|
||||
#include <aws/cloudformation/model/ListTypeRegistrationsResult.h>
|
||||
#include <aws/cloudformation/model/ListTypeVersionsResult.h>
|
||||
#include <aws/cloudformation/model/ListTypesResult.h>
|
||||
#include <aws/cloudformation/model/PublishTypeResult.h>
|
||||
#include <aws/cloudformation/model/RecordHandlerProgressResult.h>
|
||||
#include <aws/cloudformation/model/RegisterPublisherResult.h>
|
||||
#include <aws/cloudformation/model/RegisterTypeResult.h>
|
||||
#include <aws/cloudformation/model/RollbackStackResult.h>
|
||||
#include <aws/cloudformation/model/SetTypeConfigurationResult.h>
|
||||
#include <aws/cloudformation/model/SetTypeDefaultVersionResult.h>
|
||||
#include <aws/cloudformation/model/StartResourceScanResult.h>
|
||||
#include <aws/cloudformation/model/StopStackSetOperationResult.h>
|
||||
#include <aws/cloudformation/model/TestTypeResult.h>
|
||||
#include <aws/cloudformation/model/UpdateGeneratedTemplateResult.h>
|
||||
#include <aws/cloudformation/model/UpdateStackResult.h>
|
||||
#include <aws/cloudformation/model/UpdateStackInstancesResult.h>
|
||||
#include <aws/cloudformation/model/UpdateStackSetResult.h>
|
||||
#include <aws/cloudformation/model/UpdateTerminationProtectionResult.h>
|
||||
#include <aws/cloudformation/model/ValidateTemplateResult.h>
|
||||
#include <aws/cloudformation/model/DescribeOrganizationsAccessRequest.h>
|
||||
#include <aws/cloudformation/model/DescribeTypeRequest.h>
|
||||
#include <aws/cloudformation/model/ListStacksRequest.h>
|
||||
#include <aws/cloudformation/model/DeactivateOrganizationsAccessRequest.h>
|
||||
#include <aws/cloudformation/model/ListTypeVersionsRequest.h>
|
||||
#include <aws/cloudformation/model/DeactivateTypeRequest.h>
|
||||
#include <aws/cloudformation/model/ValidateTemplateRequest.h>
|
||||
#include <aws/cloudformation/model/SetTypeDefaultVersionRequest.h>
|
||||
#include <aws/cloudformation/model/TestTypeRequest.h>
|
||||
#include <aws/cloudformation/model/GetTemplateSummaryRequest.h>
|
||||
#include <aws/cloudformation/model/PublishTypeRequest.h>
|
||||
#include <aws/cloudformation/model/DeregisterTypeRequest.h>
|
||||
#include <aws/cloudformation/model/RegisterPublisherRequest.h>
|
||||
#include <aws/cloudformation/model/ListTypeRegistrationsRequest.h>
|
||||
#include <aws/cloudformation/model/DescribeAccountLimitsRequest.h>
|
||||
#include <aws/cloudformation/model/DescribeStackEventsRequest.h>
|
||||
#include <aws/cloudformation/model/ListExportsRequest.h>
|
||||
#include <aws/cloudformation/model/StartResourceScanRequest.h>
|
||||
#include <aws/cloudformation/model/DescribePublisherRequest.h>
|
||||
#include <aws/cloudformation/model/ListResourceScansRequest.h>
|
||||
#include <aws/cloudformation/model/DescribeStacksRequest.h>
|
||||
#include <aws/cloudformation/model/GetTemplateRequest.h>
|
||||
#include <aws/cloudformation/model/ListStackSetsRequest.h>
|
||||
#include <aws/cloudformation/model/DescribeStackResourcesRequest.h>
|
||||
#include <aws/cloudformation/model/ActivateOrganizationsAccessRequest.h>
|
||||
#include <aws/cloudformation/model/ActivateTypeRequest.h>
|
||||
#include <aws/cloudformation/model/ListTypesRequest.h>
|
||||
#include <aws/cloudformation/model/EstimateTemplateCostRequest.h>
|
||||
#include <aws/cloudformation/model/ListGeneratedTemplatesRequest.h>
|
||||
#include <aws/core/NoResult.h>
|
||||
/* End of service model headers required in CloudFormationClient header */
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Http
|
||||
{
|
||||
class HttpClient;
|
||||
class HttpClientFactory;
|
||||
} // namespace Http
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
template< typename R, typename E> class Outcome;
|
||||
|
||||
namespace Threading
|
||||
{
|
||||
class Executor;
|
||||
} // namespace Threading
|
||||
} // namespace Utils
|
||||
|
||||
namespace Auth
|
||||
{
|
||||
class AWSCredentials;
|
||||
class AWSCredentialsProvider;
|
||||
} // namespace Auth
|
||||
|
||||
namespace Client
|
||||
{
|
||||
class RetryStrategy;
|
||||
} // namespace Client
|
||||
|
||||
namespace CloudFormation
|
||||
{
|
||||
using CloudFormationClientConfiguration = Aws::Client::GenericClientConfiguration;
|
||||
using CloudFormationEndpointProviderBase = Aws::CloudFormation::Endpoint::CloudFormationEndpointProviderBase;
|
||||
using CloudFormationEndpointProvider = Aws::CloudFormation::Endpoint::CloudFormationEndpointProvider;
|
||||
|
||||
namespace Model
|
||||
{
|
||||
/* Service model forward declarations required in CloudFormationClient header */
|
||||
class ActivateOrganizationsAccessRequest;
|
||||
class ActivateTypeRequest;
|
||||
class BatchDescribeTypeConfigurationsRequest;
|
||||
class CancelUpdateStackRequest;
|
||||
class ContinueUpdateRollbackRequest;
|
||||
class CreateChangeSetRequest;
|
||||
class CreateGeneratedTemplateRequest;
|
||||
class CreateStackRequest;
|
||||
class CreateStackInstancesRequest;
|
||||
class CreateStackSetRequest;
|
||||
class DeactivateOrganizationsAccessRequest;
|
||||
class DeactivateTypeRequest;
|
||||
class DeleteChangeSetRequest;
|
||||
class DeleteGeneratedTemplateRequest;
|
||||
class DeleteStackRequest;
|
||||
class DeleteStackInstancesRequest;
|
||||
class DeleteStackSetRequest;
|
||||
class DeregisterTypeRequest;
|
||||
class DescribeAccountLimitsRequest;
|
||||
class DescribeChangeSetRequest;
|
||||
class DescribeChangeSetHooksRequest;
|
||||
class DescribeGeneratedTemplateRequest;
|
||||
class DescribeOrganizationsAccessRequest;
|
||||
class DescribePublisherRequest;
|
||||
class DescribeResourceScanRequest;
|
||||
class DescribeStackDriftDetectionStatusRequest;
|
||||
class DescribeStackEventsRequest;
|
||||
class DescribeStackInstanceRequest;
|
||||
class DescribeStackResourceRequest;
|
||||
class DescribeStackResourceDriftsRequest;
|
||||
class DescribeStackResourcesRequest;
|
||||
class DescribeStackSetRequest;
|
||||
class DescribeStackSetOperationRequest;
|
||||
class DescribeStacksRequest;
|
||||
class DescribeTypeRequest;
|
||||
class DescribeTypeRegistrationRequest;
|
||||
class DetectStackDriftRequest;
|
||||
class DetectStackResourceDriftRequest;
|
||||
class DetectStackSetDriftRequest;
|
||||
class EstimateTemplateCostRequest;
|
||||
class ExecuteChangeSetRequest;
|
||||
class GetGeneratedTemplateRequest;
|
||||
class GetStackPolicyRequest;
|
||||
class GetTemplateRequest;
|
||||
class GetTemplateSummaryRequest;
|
||||
class ImportStacksToStackSetRequest;
|
||||
class ListChangeSetsRequest;
|
||||
class ListExportsRequest;
|
||||
class ListGeneratedTemplatesRequest;
|
||||
class ListImportsRequest;
|
||||
class ListResourceScanRelatedResourcesRequest;
|
||||
class ListResourceScanResourcesRequest;
|
||||
class ListResourceScansRequest;
|
||||
class ListStackInstanceResourceDriftsRequest;
|
||||
class ListStackInstancesRequest;
|
||||
class ListStackResourcesRequest;
|
||||
class ListStackSetAutoDeploymentTargetsRequest;
|
||||
class ListStackSetOperationResultsRequest;
|
||||
class ListStackSetOperationsRequest;
|
||||
class ListStackSetsRequest;
|
||||
class ListStacksRequest;
|
||||
class ListTypeRegistrationsRequest;
|
||||
class ListTypeVersionsRequest;
|
||||
class ListTypesRequest;
|
||||
class PublishTypeRequest;
|
||||
class RecordHandlerProgressRequest;
|
||||
class RegisterPublisherRequest;
|
||||
class RegisterTypeRequest;
|
||||
class RollbackStackRequest;
|
||||
class SetStackPolicyRequest;
|
||||
class SetTypeConfigurationRequest;
|
||||
class SetTypeDefaultVersionRequest;
|
||||
class SignalResourceRequest;
|
||||
class StartResourceScanRequest;
|
||||
class StopStackSetOperationRequest;
|
||||
class TestTypeRequest;
|
||||
class UpdateGeneratedTemplateRequest;
|
||||
class UpdateStackRequest;
|
||||
class UpdateStackInstancesRequest;
|
||||
class UpdateStackSetRequest;
|
||||
class UpdateTerminationProtectionRequest;
|
||||
class ValidateTemplateRequest;
|
||||
/* End of service model forward declarations required in CloudFormationClient header */
|
||||
|
||||
/* Service model Outcome class definitions */
|
||||
typedef Aws::Utils::Outcome<ActivateOrganizationsAccessResult, CloudFormationError> ActivateOrganizationsAccessOutcome;
|
||||
typedef Aws::Utils::Outcome<ActivateTypeResult, CloudFormationError> ActivateTypeOutcome;
|
||||
typedef Aws::Utils::Outcome<BatchDescribeTypeConfigurationsResult, CloudFormationError> BatchDescribeTypeConfigurationsOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CloudFormationError> CancelUpdateStackOutcome;
|
||||
typedef Aws::Utils::Outcome<ContinueUpdateRollbackResult, CloudFormationError> ContinueUpdateRollbackOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateChangeSetResult, CloudFormationError> CreateChangeSetOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateGeneratedTemplateResult, CloudFormationError> CreateGeneratedTemplateOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateStackResult, CloudFormationError> CreateStackOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateStackInstancesResult, CloudFormationError> CreateStackInstancesOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateStackSetResult, CloudFormationError> CreateStackSetOutcome;
|
||||
typedef Aws::Utils::Outcome<DeactivateOrganizationsAccessResult, CloudFormationError> DeactivateOrganizationsAccessOutcome;
|
||||
typedef Aws::Utils::Outcome<DeactivateTypeResult, CloudFormationError> DeactivateTypeOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteChangeSetResult, CloudFormationError> DeleteChangeSetOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CloudFormationError> DeleteGeneratedTemplateOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CloudFormationError> DeleteStackOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteStackInstancesResult, CloudFormationError> DeleteStackInstancesOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteStackSetResult, CloudFormationError> DeleteStackSetOutcome;
|
||||
typedef Aws::Utils::Outcome<DeregisterTypeResult, CloudFormationError> DeregisterTypeOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeAccountLimitsResult, CloudFormationError> DescribeAccountLimitsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeChangeSetResult, CloudFormationError> DescribeChangeSetOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeChangeSetHooksResult, CloudFormationError> DescribeChangeSetHooksOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeGeneratedTemplateResult, CloudFormationError> DescribeGeneratedTemplateOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeOrganizationsAccessResult, CloudFormationError> DescribeOrganizationsAccessOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribePublisherResult, CloudFormationError> DescribePublisherOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeResourceScanResult, CloudFormationError> DescribeResourceScanOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeStackDriftDetectionStatusResult, CloudFormationError> DescribeStackDriftDetectionStatusOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeStackEventsResult, CloudFormationError> DescribeStackEventsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeStackInstanceResult, CloudFormationError> DescribeStackInstanceOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeStackResourceResult, CloudFormationError> DescribeStackResourceOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeStackResourceDriftsResult, CloudFormationError> DescribeStackResourceDriftsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeStackResourcesResult, CloudFormationError> DescribeStackResourcesOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeStackSetResult, CloudFormationError> DescribeStackSetOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeStackSetOperationResult, CloudFormationError> DescribeStackSetOperationOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeStacksResult, CloudFormationError> DescribeStacksOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeTypeResult, CloudFormationError> DescribeTypeOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeTypeRegistrationResult, CloudFormationError> DescribeTypeRegistrationOutcome;
|
||||
typedef Aws::Utils::Outcome<DetectStackDriftResult, CloudFormationError> DetectStackDriftOutcome;
|
||||
typedef Aws::Utils::Outcome<DetectStackResourceDriftResult, CloudFormationError> DetectStackResourceDriftOutcome;
|
||||
typedef Aws::Utils::Outcome<DetectStackSetDriftResult, CloudFormationError> DetectStackSetDriftOutcome;
|
||||
typedef Aws::Utils::Outcome<EstimateTemplateCostResult, CloudFormationError> EstimateTemplateCostOutcome;
|
||||
typedef Aws::Utils::Outcome<ExecuteChangeSetResult, CloudFormationError> ExecuteChangeSetOutcome;
|
||||
typedef Aws::Utils::Outcome<GetGeneratedTemplateResult, CloudFormationError> GetGeneratedTemplateOutcome;
|
||||
typedef Aws::Utils::Outcome<GetStackPolicyResult, CloudFormationError> GetStackPolicyOutcome;
|
||||
typedef Aws::Utils::Outcome<GetTemplateResult, CloudFormationError> GetTemplateOutcome;
|
||||
typedef Aws::Utils::Outcome<GetTemplateSummaryResult, CloudFormationError> GetTemplateSummaryOutcome;
|
||||
typedef Aws::Utils::Outcome<ImportStacksToStackSetResult, CloudFormationError> ImportStacksToStackSetOutcome;
|
||||
typedef Aws::Utils::Outcome<ListChangeSetsResult, CloudFormationError> ListChangeSetsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListExportsResult, CloudFormationError> ListExportsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListGeneratedTemplatesResult, CloudFormationError> ListGeneratedTemplatesOutcome;
|
||||
typedef Aws::Utils::Outcome<ListImportsResult, CloudFormationError> ListImportsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListResourceScanRelatedResourcesResult, CloudFormationError> ListResourceScanRelatedResourcesOutcome;
|
||||
typedef Aws::Utils::Outcome<ListResourceScanResourcesResult, CloudFormationError> ListResourceScanResourcesOutcome;
|
||||
typedef Aws::Utils::Outcome<ListResourceScansResult, CloudFormationError> ListResourceScansOutcome;
|
||||
typedef Aws::Utils::Outcome<ListStackInstanceResourceDriftsResult, CloudFormationError> ListStackInstanceResourceDriftsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListStackInstancesResult, CloudFormationError> ListStackInstancesOutcome;
|
||||
typedef Aws::Utils::Outcome<ListStackResourcesResult, CloudFormationError> ListStackResourcesOutcome;
|
||||
typedef Aws::Utils::Outcome<ListStackSetAutoDeploymentTargetsResult, CloudFormationError> ListStackSetAutoDeploymentTargetsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListStackSetOperationResultsResult, CloudFormationError> ListStackSetOperationResultsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListStackSetOperationsResult, CloudFormationError> ListStackSetOperationsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListStackSetsResult, CloudFormationError> ListStackSetsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListStacksResult, CloudFormationError> ListStacksOutcome;
|
||||
typedef Aws::Utils::Outcome<ListTypeRegistrationsResult, CloudFormationError> ListTypeRegistrationsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListTypeVersionsResult, CloudFormationError> ListTypeVersionsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListTypesResult, CloudFormationError> ListTypesOutcome;
|
||||
typedef Aws::Utils::Outcome<PublishTypeResult, CloudFormationError> PublishTypeOutcome;
|
||||
typedef Aws::Utils::Outcome<RecordHandlerProgressResult, CloudFormationError> RecordHandlerProgressOutcome;
|
||||
typedef Aws::Utils::Outcome<RegisterPublisherResult, CloudFormationError> RegisterPublisherOutcome;
|
||||
typedef Aws::Utils::Outcome<RegisterTypeResult, CloudFormationError> RegisterTypeOutcome;
|
||||
typedef Aws::Utils::Outcome<RollbackStackResult, CloudFormationError> RollbackStackOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CloudFormationError> SetStackPolicyOutcome;
|
||||
typedef Aws::Utils::Outcome<SetTypeConfigurationResult, CloudFormationError> SetTypeConfigurationOutcome;
|
||||
typedef Aws::Utils::Outcome<SetTypeDefaultVersionResult, CloudFormationError> SetTypeDefaultVersionOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CloudFormationError> SignalResourceOutcome;
|
||||
typedef Aws::Utils::Outcome<StartResourceScanResult, CloudFormationError> StartResourceScanOutcome;
|
||||
typedef Aws::Utils::Outcome<StopStackSetOperationResult, CloudFormationError> StopStackSetOperationOutcome;
|
||||
typedef Aws::Utils::Outcome<TestTypeResult, CloudFormationError> TestTypeOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateGeneratedTemplateResult, CloudFormationError> UpdateGeneratedTemplateOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateStackResult, CloudFormationError> UpdateStackOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateStackInstancesResult, CloudFormationError> UpdateStackInstancesOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateStackSetResult, CloudFormationError> UpdateStackSetOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateTerminationProtectionResult, CloudFormationError> UpdateTerminationProtectionOutcome;
|
||||
typedef Aws::Utils::Outcome<ValidateTemplateResult, CloudFormationError> ValidateTemplateOutcome;
|
||||
/* End of service model Outcome class definitions */
|
||||
|
||||
/* Service model Outcome callable definitions */
|
||||
typedef std::future<ActivateOrganizationsAccessOutcome> ActivateOrganizationsAccessOutcomeCallable;
|
||||
typedef std::future<ActivateTypeOutcome> ActivateTypeOutcomeCallable;
|
||||
typedef std::future<BatchDescribeTypeConfigurationsOutcome> BatchDescribeTypeConfigurationsOutcomeCallable;
|
||||
typedef std::future<CancelUpdateStackOutcome> CancelUpdateStackOutcomeCallable;
|
||||
typedef std::future<ContinueUpdateRollbackOutcome> ContinueUpdateRollbackOutcomeCallable;
|
||||
typedef std::future<CreateChangeSetOutcome> CreateChangeSetOutcomeCallable;
|
||||
typedef std::future<CreateGeneratedTemplateOutcome> CreateGeneratedTemplateOutcomeCallable;
|
||||
typedef std::future<CreateStackOutcome> CreateStackOutcomeCallable;
|
||||
typedef std::future<CreateStackInstancesOutcome> CreateStackInstancesOutcomeCallable;
|
||||
typedef std::future<CreateStackSetOutcome> CreateStackSetOutcomeCallable;
|
||||
typedef std::future<DeactivateOrganizationsAccessOutcome> DeactivateOrganizationsAccessOutcomeCallable;
|
||||
typedef std::future<DeactivateTypeOutcome> DeactivateTypeOutcomeCallable;
|
||||
typedef std::future<DeleteChangeSetOutcome> DeleteChangeSetOutcomeCallable;
|
||||
typedef std::future<DeleteGeneratedTemplateOutcome> DeleteGeneratedTemplateOutcomeCallable;
|
||||
typedef std::future<DeleteStackOutcome> DeleteStackOutcomeCallable;
|
||||
typedef std::future<DeleteStackInstancesOutcome> DeleteStackInstancesOutcomeCallable;
|
||||
typedef std::future<DeleteStackSetOutcome> DeleteStackSetOutcomeCallable;
|
||||
typedef std::future<DeregisterTypeOutcome> DeregisterTypeOutcomeCallable;
|
||||
typedef std::future<DescribeAccountLimitsOutcome> DescribeAccountLimitsOutcomeCallable;
|
||||
typedef std::future<DescribeChangeSetOutcome> DescribeChangeSetOutcomeCallable;
|
||||
typedef std::future<DescribeChangeSetHooksOutcome> DescribeChangeSetHooksOutcomeCallable;
|
||||
typedef std::future<DescribeGeneratedTemplateOutcome> DescribeGeneratedTemplateOutcomeCallable;
|
||||
typedef std::future<DescribeOrganizationsAccessOutcome> DescribeOrganizationsAccessOutcomeCallable;
|
||||
typedef std::future<DescribePublisherOutcome> DescribePublisherOutcomeCallable;
|
||||
typedef std::future<DescribeResourceScanOutcome> DescribeResourceScanOutcomeCallable;
|
||||
typedef std::future<DescribeStackDriftDetectionStatusOutcome> DescribeStackDriftDetectionStatusOutcomeCallable;
|
||||
typedef std::future<DescribeStackEventsOutcome> DescribeStackEventsOutcomeCallable;
|
||||
typedef std::future<DescribeStackInstanceOutcome> DescribeStackInstanceOutcomeCallable;
|
||||
typedef std::future<DescribeStackResourceOutcome> DescribeStackResourceOutcomeCallable;
|
||||
typedef std::future<DescribeStackResourceDriftsOutcome> DescribeStackResourceDriftsOutcomeCallable;
|
||||
typedef std::future<DescribeStackResourcesOutcome> DescribeStackResourcesOutcomeCallable;
|
||||
typedef std::future<DescribeStackSetOutcome> DescribeStackSetOutcomeCallable;
|
||||
typedef std::future<DescribeStackSetOperationOutcome> DescribeStackSetOperationOutcomeCallable;
|
||||
typedef std::future<DescribeStacksOutcome> DescribeStacksOutcomeCallable;
|
||||
typedef std::future<DescribeTypeOutcome> DescribeTypeOutcomeCallable;
|
||||
typedef std::future<DescribeTypeRegistrationOutcome> DescribeTypeRegistrationOutcomeCallable;
|
||||
typedef std::future<DetectStackDriftOutcome> DetectStackDriftOutcomeCallable;
|
||||
typedef std::future<DetectStackResourceDriftOutcome> DetectStackResourceDriftOutcomeCallable;
|
||||
typedef std::future<DetectStackSetDriftOutcome> DetectStackSetDriftOutcomeCallable;
|
||||
typedef std::future<EstimateTemplateCostOutcome> EstimateTemplateCostOutcomeCallable;
|
||||
typedef std::future<ExecuteChangeSetOutcome> ExecuteChangeSetOutcomeCallable;
|
||||
typedef std::future<GetGeneratedTemplateOutcome> GetGeneratedTemplateOutcomeCallable;
|
||||
typedef std::future<GetStackPolicyOutcome> GetStackPolicyOutcomeCallable;
|
||||
typedef std::future<GetTemplateOutcome> GetTemplateOutcomeCallable;
|
||||
typedef std::future<GetTemplateSummaryOutcome> GetTemplateSummaryOutcomeCallable;
|
||||
typedef std::future<ImportStacksToStackSetOutcome> ImportStacksToStackSetOutcomeCallable;
|
||||
typedef std::future<ListChangeSetsOutcome> ListChangeSetsOutcomeCallable;
|
||||
typedef std::future<ListExportsOutcome> ListExportsOutcomeCallable;
|
||||
typedef std::future<ListGeneratedTemplatesOutcome> ListGeneratedTemplatesOutcomeCallable;
|
||||
typedef std::future<ListImportsOutcome> ListImportsOutcomeCallable;
|
||||
typedef std::future<ListResourceScanRelatedResourcesOutcome> ListResourceScanRelatedResourcesOutcomeCallable;
|
||||
typedef std::future<ListResourceScanResourcesOutcome> ListResourceScanResourcesOutcomeCallable;
|
||||
typedef std::future<ListResourceScansOutcome> ListResourceScansOutcomeCallable;
|
||||
typedef std::future<ListStackInstanceResourceDriftsOutcome> ListStackInstanceResourceDriftsOutcomeCallable;
|
||||
typedef std::future<ListStackInstancesOutcome> ListStackInstancesOutcomeCallable;
|
||||
typedef std::future<ListStackResourcesOutcome> ListStackResourcesOutcomeCallable;
|
||||
typedef std::future<ListStackSetAutoDeploymentTargetsOutcome> ListStackSetAutoDeploymentTargetsOutcomeCallable;
|
||||
typedef std::future<ListStackSetOperationResultsOutcome> ListStackSetOperationResultsOutcomeCallable;
|
||||
typedef std::future<ListStackSetOperationsOutcome> ListStackSetOperationsOutcomeCallable;
|
||||
typedef std::future<ListStackSetsOutcome> ListStackSetsOutcomeCallable;
|
||||
typedef std::future<ListStacksOutcome> ListStacksOutcomeCallable;
|
||||
typedef std::future<ListTypeRegistrationsOutcome> ListTypeRegistrationsOutcomeCallable;
|
||||
typedef std::future<ListTypeVersionsOutcome> ListTypeVersionsOutcomeCallable;
|
||||
typedef std::future<ListTypesOutcome> ListTypesOutcomeCallable;
|
||||
typedef std::future<PublishTypeOutcome> PublishTypeOutcomeCallable;
|
||||
typedef std::future<RecordHandlerProgressOutcome> RecordHandlerProgressOutcomeCallable;
|
||||
typedef std::future<RegisterPublisherOutcome> RegisterPublisherOutcomeCallable;
|
||||
typedef std::future<RegisterTypeOutcome> RegisterTypeOutcomeCallable;
|
||||
typedef std::future<RollbackStackOutcome> RollbackStackOutcomeCallable;
|
||||
typedef std::future<SetStackPolicyOutcome> SetStackPolicyOutcomeCallable;
|
||||
typedef std::future<SetTypeConfigurationOutcome> SetTypeConfigurationOutcomeCallable;
|
||||
typedef std::future<SetTypeDefaultVersionOutcome> SetTypeDefaultVersionOutcomeCallable;
|
||||
typedef std::future<SignalResourceOutcome> SignalResourceOutcomeCallable;
|
||||
typedef std::future<StartResourceScanOutcome> StartResourceScanOutcomeCallable;
|
||||
typedef std::future<StopStackSetOperationOutcome> StopStackSetOperationOutcomeCallable;
|
||||
typedef std::future<TestTypeOutcome> TestTypeOutcomeCallable;
|
||||
typedef std::future<UpdateGeneratedTemplateOutcome> UpdateGeneratedTemplateOutcomeCallable;
|
||||
typedef std::future<UpdateStackOutcome> UpdateStackOutcomeCallable;
|
||||
typedef std::future<UpdateStackInstancesOutcome> UpdateStackInstancesOutcomeCallable;
|
||||
typedef std::future<UpdateStackSetOutcome> UpdateStackSetOutcomeCallable;
|
||||
typedef std::future<UpdateTerminationProtectionOutcome> UpdateTerminationProtectionOutcomeCallable;
|
||||
typedef std::future<ValidateTemplateOutcome> ValidateTemplateOutcomeCallable;
|
||||
/* End of service model Outcome callable definitions */
|
||||
} // namespace Model
|
||||
|
||||
class CloudFormationClient;
|
||||
|
||||
/* Service model async handlers definitions */
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ActivateOrganizationsAccessRequest&, const Model::ActivateOrganizationsAccessOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ActivateOrganizationsAccessResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ActivateTypeRequest&, const Model::ActivateTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ActivateTypeResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::BatchDescribeTypeConfigurationsRequest&, const Model::BatchDescribeTypeConfigurationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchDescribeTypeConfigurationsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::CancelUpdateStackRequest&, const Model::CancelUpdateStackOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CancelUpdateStackResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ContinueUpdateRollbackRequest&, const Model::ContinueUpdateRollbackOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ContinueUpdateRollbackResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::CreateChangeSetRequest&, const Model::CreateChangeSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateChangeSetResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::CreateGeneratedTemplateRequest&, const Model::CreateGeneratedTemplateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateGeneratedTemplateResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::CreateStackRequest&, const Model::CreateStackOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateStackResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::CreateStackInstancesRequest&, const Model::CreateStackInstancesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateStackInstancesResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::CreateStackSetRequest&, const Model::CreateStackSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateStackSetResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DeactivateOrganizationsAccessRequest&, const Model::DeactivateOrganizationsAccessOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeactivateOrganizationsAccessResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DeactivateTypeRequest&, const Model::DeactivateTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeactivateTypeResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DeleteChangeSetRequest&, const Model::DeleteChangeSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteChangeSetResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DeleteGeneratedTemplateRequest&, const Model::DeleteGeneratedTemplateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteGeneratedTemplateResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DeleteStackRequest&, const Model::DeleteStackOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteStackResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DeleteStackInstancesRequest&, const Model::DeleteStackInstancesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteStackInstancesResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DeleteStackSetRequest&, const Model::DeleteStackSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteStackSetResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DeregisterTypeRequest&, const Model::DeregisterTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeregisterTypeResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeAccountLimitsRequest&, const Model::DescribeAccountLimitsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeAccountLimitsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeChangeSetRequest&, const Model::DescribeChangeSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeChangeSetResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeChangeSetHooksRequest&, const Model::DescribeChangeSetHooksOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeChangeSetHooksResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeGeneratedTemplateRequest&, const Model::DescribeGeneratedTemplateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGeneratedTemplateResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeOrganizationsAccessRequest&, const Model::DescribeOrganizationsAccessOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeOrganizationsAccessResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribePublisherRequest&, const Model::DescribePublisherOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribePublisherResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeResourceScanRequest&, const Model::DescribeResourceScanOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeResourceScanResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeStackDriftDetectionStatusRequest&, const Model::DescribeStackDriftDetectionStatusOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStackDriftDetectionStatusResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeStackEventsRequest&, const Model::DescribeStackEventsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStackEventsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeStackInstanceRequest&, const Model::DescribeStackInstanceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStackInstanceResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeStackResourceRequest&, const Model::DescribeStackResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStackResourceResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeStackResourceDriftsRequest&, const Model::DescribeStackResourceDriftsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStackResourceDriftsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeStackResourcesRequest&, const Model::DescribeStackResourcesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStackResourcesResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeStackSetRequest&, const Model::DescribeStackSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStackSetResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeStackSetOperationRequest&, const Model::DescribeStackSetOperationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStackSetOperationResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeStacksRequest&, const Model::DescribeStacksOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStacksResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeTypeRequest&, const Model::DescribeTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeTypeResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DescribeTypeRegistrationRequest&, const Model::DescribeTypeRegistrationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeTypeRegistrationResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DetectStackDriftRequest&, const Model::DetectStackDriftOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DetectStackDriftResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DetectStackResourceDriftRequest&, const Model::DetectStackResourceDriftOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DetectStackResourceDriftResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::DetectStackSetDriftRequest&, const Model::DetectStackSetDriftOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DetectStackSetDriftResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::EstimateTemplateCostRequest&, const Model::EstimateTemplateCostOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > EstimateTemplateCostResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ExecuteChangeSetRequest&, const Model::ExecuteChangeSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ExecuteChangeSetResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::GetGeneratedTemplateRequest&, const Model::GetGeneratedTemplateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetGeneratedTemplateResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::GetStackPolicyRequest&, const Model::GetStackPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetStackPolicyResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::GetTemplateRequest&, const Model::GetTemplateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetTemplateResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::GetTemplateSummaryRequest&, const Model::GetTemplateSummaryOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetTemplateSummaryResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ImportStacksToStackSetRequest&, const Model::ImportStacksToStackSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ImportStacksToStackSetResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListChangeSetsRequest&, const Model::ListChangeSetsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListChangeSetsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListExportsRequest&, const Model::ListExportsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListExportsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListGeneratedTemplatesRequest&, const Model::ListGeneratedTemplatesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListGeneratedTemplatesResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListImportsRequest&, const Model::ListImportsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListImportsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListResourceScanRelatedResourcesRequest&, const Model::ListResourceScanRelatedResourcesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListResourceScanRelatedResourcesResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListResourceScanResourcesRequest&, const Model::ListResourceScanResourcesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListResourceScanResourcesResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListResourceScansRequest&, const Model::ListResourceScansOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListResourceScansResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListStackInstanceResourceDriftsRequest&, const Model::ListStackInstanceResourceDriftsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStackInstanceResourceDriftsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListStackInstancesRequest&, const Model::ListStackInstancesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStackInstancesResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListStackResourcesRequest&, const Model::ListStackResourcesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStackResourcesResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListStackSetAutoDeploymentTargetsRequest&, const Model::ListStackSetAutoDeploymentTargetsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStackSetAutoDeploymentTargetsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListStackSetOperationResultsRequest&, const Model::ListStackSetOperationResultsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStackSetOperationResultsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListStackSetOperationsRequest&, const Model::ListStackSetOperationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStackSetOperationsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListStackSetsRequest&, const Model::ListStackSetsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStackSetsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListStacksRequest&, const Model::ListStacksOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStacksResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListTypeRegistrationsRequest&, const Model::ListTypeRegistrationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTypeRegistrationsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListTypeVersionsRequest&, const Model::ListTypeVersionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTypeVersionsResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ListTypesRequest&, const Model::ListTypesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTypesResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::PublishTypeRequest&, const Model::PublishTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PublishTypeResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::RecordHandlerProgressRequest&, const Model::RecordHandlerProgressOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RecordHandlerProgressResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::RegisterPublisherRequest&, const Model::RegisterPublisherOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterPublisherResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::RegisterTypeRequest&, const Model::RegisterTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterTypeResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::RollbackStackRequest&, const Model::RollbackStackOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RollbackStackResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::SetStackPolicyRequest&, const Model::SetStackPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SetStackPolicyResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::SetTypeConfigurationRequest&, const Model::SetTypeConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SetTypeConfigurationResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::SetTypeDefaultVersionRequest&, const Model::SetTypeDefaultVersionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SetTypeDefaultVersionResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::SignalResourceRequest&, const Model::SignalResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SignalResourceResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::StartResourceScanRequest&, const Model::StartResourceScanOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartResourceScanResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::StopStackSetOperationRequest&, const Model::StopStackSetOperationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopStackSetOperationResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::TestTypeRequest&, const Model::TestTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TestTypeResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::UpdateGeneratedTemplateRequest&, const Model::UpdateGeneratedTemplateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateGeneratedTemplateResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::UpdateStackRequest&, const Model::UpdateStackOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateStackResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::UpdateStackInstancesRequest&, const Model::UpdateStackInstancesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateStackInstancesResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::UpdateStackSetRequest&, const Model::UpdateStackSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateStackSetResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::UpdateTerminationProtectionRequest&, const Model::UpdateTerminationProtectionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateTerminationProtectionResponseReceivedHandler;
|
||||
typedef std::function<void(const CloudFormationClient*, const Model::ValidateTemplateRequest&, const Model::ValidateTemplateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ValidateTemplateResponseReceivedHandler;
|
||||
/* End of service model async handlers definitions */
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifdef _MSC_VER
|
||||
//disable windows complaining about max template size.
|
||||
#pragma warning (disable : 4503)
|
||||
#endif // _MSC_VER
|
||||
|
||||
#if defined (USE_WINDOWS_DLL_SEMANTICS) || defined (_WIN32)
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(disable : 4251)
|
||||
#endif // _MSC_VER
|
||||
|
||||
#ifdef USE_IMPORT_EXPORT
|
||||
#ifdef AWS_CLOUDFORMATION_EXPORTS
|
||||
#define AWS_CLOUDFORMATION_API __declspec(dllexport)
|
||||
#else
|
||||
#define AWS_CLOUDFORMATION_API __declspec(dllimport)
|
||||
#endif /* AWS_CLOUDFORMATION_EXPORTS */
|
||||
#define AWS_CLOUDFORMATION_EXTERN
|
||||
#else
|
||||
#define AWS_CLOUDFORMATION_API
|
||||
#define AWS_CLOUDFORMATION_EXTERN extern
|
||||
#endif // USE_IMPORT_EXPORT
|
||||
#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
|
||||
#define AWS_CLOUDFORMATION_API
|
||||
#define AWS_CLOUDFORMATION_EXTERN extern
|
||||
#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
|
||||
@@ -0,0 +1,43 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
#ifdef DIFFERENCE
|
||||
#undef DIFFERENCE
|
||||
#define RESTORE_DIFFERENCE
|
||||
#endif
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class AccountFilterType
|
||||
{
|
||||
NOT_SET,
|
||||
NONE,
|
||||
INTERSECTION,
|
||||
DIFFERENCE,
|
||||
UNION
|
||||
};
|
||||
|
||||
namespace AccountFilterTypeMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API AccountFilterType GetAccountFilterTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForAccountFilterType(AccountFilterType value);
|
||||
} // namespace AccountFilterTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
|
||||
#ifdef RESTORE_DIFFERENCE
|
||||
#define DIFFERENCE
|
||||
#undef RESTORE_DIFFERENCE
|
||||
#endif
|
||||
@@ -0,0 +1,110 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
|
||||
#include <aws/cloudformation/model/AccountGateStatus.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlNode;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Structure that contains the results of the account gate function which
|
||||
* CloudFormation invokes, if present, before proceeding with a stack set operation
|
||||
* in an account and Region.</p> <p>For each account and Region, CloudFormation
|
||||
* lets you specify a Lambda function that encapsulates any requirements that must
|
||||
* be met before CloudFormation can proceed with a stack set operation in that
|
||||
* account and Region. CloudFormation invokes the function each time a stack set
|
||||
* operation is requested for that account and Region; if the function returns
|
||||
* <code>FAILED</code>, CloudFormation cancels the operation in that account and
|
||||
* Region, and sets the stack set operation result status for that account and
|
||||
* Region to <code>FAILED</code>.</p> <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-account-gating.html">Configuring
|
||||
* a target account gate</a>.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/AccountGateResult">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AccountGateResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API AccountGateResult();
|
||||
AWS_CLOUDFORMATION_API AccountGateResult(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
AWS_CLOUDFORMATION_API AccountGateResult& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The status of the account gate function.</p> <ul> <li> <p>
|
||||
* <code>SUCCEEDED</code>: The account gate function has determined that the
|
||||
* account and Region passes any requirements for a stack set operation to occur.
|
||||
* CloudFormation proceeds with the stack operation in that account and Region.</p>
|
||||
* </li> <li> <p> <code>FAILED</code>: The account gate function has determined
|
||||
* that the account and Region doesn't meet the requirements for a stack set
|
||||
* operation to occur. CloudFormation cancels the stack set operation in that
|
||||
* account and Region, and sets the stack set operation result status for that
|
||||
* account and Region to <code>FAILED</code>.</p> </li> <li> <p>
|
||||
* <code>SKIPPED</code>: CloudFormation has skipped calling the account gate
|
||||
* function for this account and Region, for one of the following reasons:</p> <ul>
|
||||
* <li> <p>An account gate function hasn't been specified for the account and
|
||||
* Region. CloudFormation proceeds with the stack set operation in this account and
|
||||
* Region.</p> </li> <li> <p>The
|
||||
* <code>AWSCloudFormationStackSetExecutionRole</code> of the stack set
|
||||
* administration account lacks permissions to invoke the function. CloudFormation
|
||||
* proceeds with the stack set operation in this account and Region.</p> </li> <li>
|
||||
* <p>Either no action is necessary, or no action is possible, on the stack.
|
||||
* CloudFormation skips the stack set operation in this account and Region.</p>
|
||||
* </li> </ul> </li> </ul>
|
||||
*/
|
||||
inline const AccountGateStatus& GetStatus() const{ return m_status; }
|
||||
inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
|
||||
inline void SetStatus(const AccountGateStatus& value) { m_statusHasBeenSet = true; m_status = value; }
|
||||
inline void SetStatus(AccountGateStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
|
||||
inline AccountGateResult& WithStatus(const AccountGateStatus& value) { SetStatus(value); return *this;}
|
||||
inline AccountGateResult& WithStatus(AccountGateStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The reason for the account gate status assigned to this account and Region
|
||||
* for the stack set operation.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStatusReason() const{ return m_statusReason; }
|
||||
inline bool StatusReasonHasBeenSet() const { return m_statusReasonHasBeenSet; }
|
||||
inline void SetStatusReason(const Aws::String& value) { m_statusReasonHasBeenSet = true; m_statusReason = value; }
|
||||
inline void SetStatusReason(Aws::String&& value) { m_statusReasonHasBeenSet = true; m_statusReason = std::move(value); }
|
||||
inline void SetStatusReason(const char* value) { m_statusReasonHasBeenSet = true; m_statusReason.assign(value); }
|
||||
inline AccountGateResult& WithStatusReason(const Aws::String& value) { SetStatusReason(value); return *this;}
|
||||
inline AccountGateResult& WithStatusReason(Aws::String&& value) { SetStatusReason(std::move(value)); return *this;}
|
||||
inline AccountGateResult& WithStatusReason(const char* value) { SetStatusReason(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
AccountGateStatus m_status;
|
||||
bool m_statusHasBeenSet = false;
|
||||
|
||||
Aws::String m_statusReason;
|
||||
bool m_statusReasonHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class AccountGateStatus
|
||||
{
|
||||
NOT_SET,
|
||||
SUCCEEDED,
|
||||
FAILED,
|
||||
SKIPPED
|
||||
};
|
||||
|
||||
namespace AccountGateStatusMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API AccountGateStatus GetAccountGateStatusForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForAccountGateStatus(AccountGateStatus value);
|
||||
} // namespace AccountGateStatusMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,85 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlNode;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The AccountLimit data type.</p> <p>CloudFormation has the following limits
|
||||
* per account:</p> <ul> <li> <p>Number of concurrent resources</p> </li> <li>
|
||||
* <p>Number of stacks</p> </li> <li> <p>Number of stack outputs</p> </li> </ul>
|
||||
* <p>For more information about these account limits, and other CloudFormation
|
||||
* limits, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html">Understand
|
||||
* CloudFormation quotas</a> in the <i>CloudFormation User Guide</i>.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/AccountLimit">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AccountLimit
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API AccountLimit();
|
||||
AWS_CLOUDFORMATION_API AccountLimit(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
AWS_CLOUDFORMATION_API AccountLimit& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the account limit.</p> <p>Values:
|
||||
* <code>ConcurrentResourcesLimit</code> | <code>StackLimit</code> |
|
||||
* <code>StackOutputsLimit</code> </p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline AccountLimit& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline AccountLimit& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline AccountLimit& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The value that's associated with the account limit name.</p>
|
||||
*/
|
||||
inline int GetValue() const{ return m_value; }
|
||||
inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
|
||||
inline void SetValue(int value) { m_valueHasBeenSet = true; m_value = value; }
|
||||
inline AccountLimit& WithValue(int value) { SetValue(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
int m_value;
|
||||
bool m_valueHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,40 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class ActivateOrganizationsAccessRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API ActivateOrganizationsAccessRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "ActivateOrganizationsAccess"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class ActivateOrganizationsAccessResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API ActivateOrganizationsAccessResult();
|
||||
AWS_CLOUDFORMATION_API ActivateOrganizationsAccessResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API ActivateOrganizationsAccessResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline ActivateOrganizationsAccessResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline ActivateOrganizationsAccessResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,228 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/cloudformation/model/ThirdPartyType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/LoggingConfig.h>
|
||||
#include <aws/cloudformation/model/VersionBump.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class ActivateTypeRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API ActivateTypeRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "ActivateType"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The extension type.</p> <p>Conditional: You must specify
|
||||
* <code>PublicTypeArn</code>, or <code>TypeName</code>, <code>Type</code>, and
|
||||
* <code>PublisherId</code>.</p>
|
||||
*/
|
||||
inline const ThirdPartyType& GetType() const{ return m_type; }
|
||||
inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
|
||||
inline void SetType(const ThirdPartyType& value) { m_typeHasBeenSet = true; m_type = value; }
|
||||
inline void SetType(ThirdPartyType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
|
||||
inline ActivateTypeRequest& WithType(const ThirdPartyType& value) { SetType(value); return *this;}
|
||||
inline ActivateTypeRequest& WithType(ThirdPartyType&& value) { SetType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the public extension.</p> <p>Conditional:
|
||||
* You must specify <code>PublicTypeArn</code>, or <code>TypeName</code>,
|
||||
* <code>Type</code>, and <code>PublisherId</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPublicTypeArn() const{ return m_publicTypeArn; }
|
||||
inline bool PublicTypeArnHasBeenSet() const { return m_publicTypeArnHasBeenSet; }
|
||||
inline void SetPublicTypeArn(const Aws::String& value) { m_publicTypeArnHasBeenSet = true; m_publicTypeArn = value; }
|
||||
inline void SetPublicTypeArn(Aws::String&& value) { m_publicTypeArnHasBeenSet = true; m_publicTypeArn = std::move(value); }
|
||||
inline void SetPublicTypeArn(const char* value) { m_publicTypeArnHasBeenSet = true; m_publicTypeArn.assign(value); }
|
||||
inline ActivateTypeRequest& WithPublicTypeArn(const Aws::String& value) { SetPublicTypeArn(value); return *this;}
|
||||
inline ActivateTypeRequest& WithPublicTypeArn(Aws::String&& value) { SetPublicTypeArn(std::move(value)); return *this;}
|
||||
inline ActivateTypeRequest& WithPublicTypeArn(const char* value) { SetPublicTypeArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the extension publisher.</p> <p>Conditional: You must specify
|
||||
* <code>PublicTypeArn</code>, or <code>TypeName</code>, <code>Type</code>, and
|
||||
* <code>PublisherId</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPublisherId() const{ return m_publisherId; }
|
||||
inline bool PublisherIdHasBeenSet() const { return m_publisherIdHasBeenSet; }
|
||||
inline void SetPublisherId(const Aws::String& value) { m_publisherIdHasBeenSet = true; m_publisherId = value; }
|
||||
inline void SetPublisherId(Aws::String&& value) { m_publisherIdHasBeenSet = true; m_publisherId = std::move(value); }
|
||||
inline void SetPublisherId(const char* value) { m_publisherIdHasBeenSet = true; m_publisherId.assign(value); }
|
||||
inline ActivateTypeRequest& WithPublisherId(const Aws::String& value) { SetPublisherId(value); return *this;}
|
||||
inline ActivateTypeRequest& WithPublisherId(Aws::String&& value) { SetPublisherId(std::move(value)); return *this;}
|
||||
inline ActivateTypeRequest& WithPublisherId(const char* value) { SetPublisherId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the extension.</p> <p>Conditional: You must specify
|
||||
* <code>PublicTypeArn</code>, or <code>TypeName</code>, <code>Type</code>, and
|
||||
* <code>PublisherId</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTypeName() const{ return m_typeName; }
|
||||
inline bool TypeNameHasBeenSet() const { return m_typeNameHasBeenSet; }
|
||||
inline void SetTypeName(const Aws::String& value) { m_typeNameHasBeenSet = true; m_typeName = value; }
|
||||
inline void SetTypeName(Aws::String&& value) { m_typeNameHasBeenSet = true; m_typeName = std::move(value); }
|
||||
inline void SetTypeName(const char* value) { m_typeNameHasBeenSet = true; m_typeName.assign(value); }
|
||||
inline ActivateTypeRequest& WithTypeName(const Aws::String& value) { SetTypeName(value); return *this;}
|
||||
inline ActivateTypeRequest& WithTypeName(Aws::String&& value) { SetTypeName(std::move(value)); return *this;}
|
||||
inline ActivateTypeRequest& WithTypeName(const char* value) { SetTypeName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An alias to assign to the public extension, in this account and Region. If
|
||||
* you specify an alias for the extension, CloudFormation treats the alias as the
|
||||
* extension type name within this account and Region. You must use the alias to
|
||||
* refer to the extension in your templates, API calls, and CloudFormation
|
||||
* console.</p> <p>An extension alias must be unique within a given account and
|
||||
* Region. You can activate the same public resource multiple times in the same
|
||||
* account and Region, using different type name aliases.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTypeNameAlias() const{ return m_typeNameAlias; }
|
||||
inline bool TypeNameAliasHasBeenSet() const { return m_typeNameAliasHasBeenSet; }
|
||||
inline void SetTypeNameAlias(const Aws::String& value) { m_typeNameAliasHasBeenSet = true; m_typeNameAlias = value; }
|
||||
inline void SetTypeNameAlias(Aws::String&& value) { m_typeNameAliasHasBeenSet = true; m_typeNameAlias = std::move(value); }
|
||||
inline void SetTypeNameAlias(const char* value) { m_typeNameAliasHasBeenSet = true; m_typeNameAlias.assign(value); }
|
||||
inline ActivateTypeRequest& WithTypeNameAlias(const Aws::String& value) { SetTypeNameAlias(value); return *this;}
|
||||
inline ActivateTypeRequest& WithTypeNameAlias(Aws::String&& value) { SetTypeNameAlias(std::move(value)); return *this;}
|
||||
inline ActivateTypeRequest& WithTypeNameAlias(const char* value) { SetTypeNameAlias(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Whether to automatically update the extension in this account and Region when
|
||||
* a new <i>minor</i> version is published by the extension publisher. Major
|
||||
* versions released by the publisher must be manually updated.</p> <p>The default
|
||||
* is <code>true</code>.</p>
|
||||
*/
|
||||
inline bool GetAutoUpdate() const{ return m_autoUpdate; }
|
||||
inline bool AutoUpdateHasBeenSet() const { return m_autoUpdateHasBeenSet; }
|
||||
inline void SetAutoUpdate(bool value) { m_autoUpdateHasBeenSet = true; m_autoUpdate = value; }
|
||||
inline ActivateTypeRequest& WithAutoUpdate(bool value) { SetAutoUpdate(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Contains logging configuration information for an extension.</p>
|
||||
*/
|
||||
inline const LoggingConfig& GetLoggingConfig() const{ return m_loggingConfig; }
|
||||
inline bool LoggingConfigHasBeenSet() const { return m_loggingConfigHasBeenSet; }
|
||||
inline void SetLoggingConfig(const LoggingConfig& value) { m_loggingConfigHasBeenSet = true; m_loggingConfig = value; }
|
||||
inline void SetLoggingConfig(LoggingConfig&& value) { m_loggingConfigHasBeenSet = true; m_loggingConfig = std::move(value); }
|
||||
inline ActivateTypeRequest& WithLoggingConfig(const LoggingConfig& value) { SetLoggingConfig(value); return *this;}
|
||||
inline ActivateTypeRequest& WithLoggingConfig(LoggingConfig&& value) { SetLoggingConfig(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the IAM execution role to use to activate the extension.</p>
|
||||
*/
|
||||
inline const Aws::String& GetExecutionRoleArn() const{ return m_executionRoleArn; }
|
||||
inline bool ExecutionRoleArnHasBeenSet() const { return m_executionRoleArnHasBeenSet; }
|
||||
inline void SetExecutionRoleArn(const Aws::String& value) { m_executionRoleArnHasBeenSet = true; m_executionRoleArn = value; }
|
||||
inline void SetExecutionRoleArn(Aws::String&& value) { m_executionRoleArnHasBeenSet = true; m_executionRoleArn = std::move(value); }
|
||||
inline void SetExecutionRoleArn(const char* value) { m_executionRoleArnHasBeenSet = true; m_executionRoleArn.assign(value); }
|
||||
inline ActivateTypeRequest& WithExecutionRoleArn(const Aws::String& value) { SetExecutionRoleArn(value); return *this;}
|
||||
inline ActivateTypeRequest& WithExecutionRoleArn(Aws::String&& value) { SetExecutionRoleArn(std::move(value)); return *this;}
|
||||
inline ActivateTypeRequest& WithExecutionRoleArn(const char* value) { SetExecutionRoleArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Manually updates a previously-activated type to a new major or minor version,
|
||||
* if available. You can also use this parameter to update the value of
|
||||
* <code>AutoUpdate</code>.</p> <ul> <li> <p> <code>MAJOR</code>: CloudFormation
|
||||
* updates the extension to the newest major version, if one is available.</p>
|
||||
* </li> <li> <p> <code>MINOR</code>: CloudFormation updates the extension to the
|
||||
* newest minor version, if one is available.</p> </li> </ul>
|
||||
*/
|
||||
inline const VersionBump& GetVersionBump() const{ return m_versionBump; }
|
||||
inline bool VersionBumpHasBeenSet() const { return m_versionBumpHasBeenSet; }
|
||||
inline void SetVersionBump(const VersionBump& value) { m_versionBumpHasBeenSet = true; m_versionBump = value; }
|
||||
inline void SetVersionBump(VersionBump&& value) { m_versionBumpHasBeenSet = true; m_versionBump = std::move(value); }
|
||||
inline ActivateTypeRequest& WithVersionBump(const VersionBump& value) { SetVersionBump(value); return *this;}
|
||||
inline ActivateTypeRequest& WithVersionBump(VersionBump&& value) { SetVersionBump(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The major version of this extension you want to activate, if multiple major
|
||||
* versions are available. The default is the latest major version. CloudFormation
|
||||
* uses the latest available <i>minor</i> version of the major version
|
||||
* selected.</p> <p>You can specify <code>MajorVersion</code> or
|
||||
* <code>VersionBump</code>, but not both.</p>
|
||||
*/
|
||||
inline long long GetMajorVersion() const{ return m_majorVersion; }
|
||||
inline bool MajorVersionHasBeenSet() const { return m_majorVersionHasBeenSet; }
|
||||
inline void SetMajorVersion(long long value) { m_majorVersionHasBeenSet = true; m_majorVersion = value; }
|
||||
inline ActivateTypeRequest& WithMajorVersion(long long value) { SetMajorVersion(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ThirdPartyType m_type;
|
||||
bool m_typeHasBeenSet = false;
|
||||
|
||||
Aws::String m_publicTypeArn;
|
||||
bool m_publicTypeArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_publisherId;
|
||||
bool m_publisherIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_typeName;
|
||||
bool m_typeNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_typeNameAlias;
|
||||
bool m_typeNameAliasHasBeenSet = false;
|
||||
|
||||
bool m_autoUpdate;
|
||||
bool m_autoUpdateHasBeenSet = false;
|
||||
|
||||
LoggingConfig m_loggingConfig;
|
||||
bool m_loggingConfigHasBeenSet = false;
|
||||
|
||||
Aws::String m_executionRoleArn;
|
||||
bool m_executionRoleArnHasBeenSet = false;
|
||||
|
||||
VersionBump m_versionBump;
|
||||
bool m_versionBumpHasBeenSet = false;
|
||||
|
||||
long long m_majorVersion;
|
||||
bool m_majorVersionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class ActivateTypeResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API ActivateTypeResult();
|
||||
AWS_CLOUDFORMATION_API ActivateTypeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API ActivateTypeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the activated extension, in this account
|
||||
* and Region.</p>
|
||||
*/
|
||||
inline const Aws::String& GetArn() const{ return m_arn; }
|
||||
inline void SetArn(const Aws::String& value) { m_arn = value; }
|
||||
inline void SetArn(Aws::String&& value) { m_arn = std::move(value); }
|
||||
inline void SetArn(const char* value) { m_arn.assign(value); }
|
||||
inline ActivateTypeResult& WithArn(const Aws::String& value) { SetArn(value); return *this;}
|
||||
inline ActivateTypeResult& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
|
||||
inline ActivateTypeResult& WithArn(const char* value) { SetArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline ActivateTypeResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline ActivateTypeResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_arn;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class AttributeChangeType
|
||||
{
|
||||
NOT_SET,
|
||||
Add,
|
||||
Remove,
|
||||
Modify
|
||||
};
|
||||
|
||||
namespace AttributeChangeTypeMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API AttributeChangeType GetAttributeChangeTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForAttributeChangeType(AttributeChangeType value);
|
||||
} // namespace AttributeChangeTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,79 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlNode;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>[Service-managed permissions] Describes whether StackSets automatically
|
||||
* deploys to Organizations accounts that are added to a target organization or
|
||||
* organizational unit (OU).</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/AutoDeployment">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AutoDeployment
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API AutoDeployment();
|
||||
AWS_CLOUDFORMATION_API AutoDeployment(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
AWS_CLOUDFORMATION_API AutoDeployment& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If set to <code>true</code>, StackSets automatically deploys additional stack
|
||||
* instances to Organizations accounts that are added to a target organization or
|
||||
* organizational unit (OU) in the specified Regions. If an account is removed from
|
||||
* a target organization or OU, StackSets deletes stack instances from the account
|
||||
* in the specified Regions.</p>
|
||||
*/
|
||||
inline bool GetEnabled() const{ return m_enabled; }
|
||||
inline bool EnabledHasBeenSet() const { return m_enabledHasBeenSet; }
|
||||
inline void SetEnabled(bool value) { m_enabledHasBeenSet = true; m_enabled = value; }
|
||||
inline AutoDeployment& WithEnabled(bool value) { SetEnabled(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If set to <code>true</code>, stack resources are retained when an account is
|
||||
* removed from a target organization or OU. If set to <code>false</code>, stack
|
||||
* resources are deleted. Specify only if <code>Enabled</code> is set to
|
||||
* <code>True</code>.</p>
|
||||
*/
|
||||
inline bool GetRetainStacksOnAccountRemoval() const{ return m_retainStacksOnAccountRemoval; }
|
||||
inline bool RetainStacksOnAccountRemovalHasBeenSet() const { return m_retainStacksOnAccountRemovalHasBeenSet; }
|
||||
inline void SetRetainStacksOnAccountRemoval(bool value) { m_retainStacksOnAccountRemovalHasBeenSet = true; m_retainStacksOnAccountRemoval = value; }
|
||||
inline AutoDeployment& WithRetainStacksOnAccountRemoval(bool value) { SetRetainStacksOnAccountRemoval(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
bool m_enabled;
|
||||
bool m_enabledHasBeenSet = false;
|
||||
|
||||
bool m_retainStacksOnAccountRemoval;
|
||||
bool m_retainStacksOnAccountRemovalHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/TypeConfigurationIdentifier.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlNode;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Detailed information concerning an error generated during the setting of
|
||||
* configuration data for a CloudFormation extension.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/BatchDescribeTypeConfigurationsError">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class BatchDescribeTypeConfigurationsError
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API BatchDescribeTypeConfigurationsError();
|
||||
AWS_CLOUDFORMATION_API BatchDescribeTypeConfigurationsError(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
AWS_CLOUDFORMATION_API BatchDescribeTypeConfigurationsError& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The error code.</p>
|
||||
*/
|
||||
inline const Aws::String& GetErrorCode() const{ return m_errorCode; }
|
||||
inline bool ErrorCodeHasBeenSet() const { return m_errorCodeHasBeenSet; }
|
||||
inline void SetErrorCode(const Aws::String& value) { m_errorCodeHasBeenSet = true; m_errorCode = value; }
|
||||
inline void SetErrorCode(Aws::String&& value) { m_errorCodeHasBeenSet = true; m_errorCode = std::move(value); }
|
||||
inline void SetErrorCode(const char* value) { m_errorCodeHasBeenSet = true; m_errorCode.assign(value); }
|
||||
inline BatchDescribeTypeConfigurationsError& WithErrorCode(const Aws::String& value) { SetErrorCode(value); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsError& WithErrorCode(Aws::String&& value) { SetErrorCode(std::move(value)); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsError& WithErrorCode(const char* value) { SetErrorCode(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The error message.</p>
|
||||
*/
|
||||
inline const Aws::String& GetErrorMessage() const{ return m_errorMessage; }
|
||||
inline bool ErrorMessageHasBeenSet() const { return m_errorMessageHasBeenSet; }
|
||||
inline void SetErrorMessage(const Aws::String& value) { m_errorMessageHasBeenSet = true; m_errorMessage = value; }
|
||||
inline void SetErrorMessage(Aws::String&& value) { m_errorMessageHasBeenSet = true; m_errorMessage = std::move(value); }
|
||||
inline void SetErrorMessage(const char* value) { m_errorMessageHasBeenSet = true; m_errorMessage.assign(value); }
|
||||
inline BatchDescribeTypeConfigurationsError& WithErrorMessage(const Aws::String& value) { SetErrorMessage(value); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsError& WithErrorMessage(Aws::String&& value) { SetErrorMessage(std::move(value)); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsError& WithErrorMessage(const char* value) { SetErrorMessage(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Identifying information for the configuration of a CloudFormation
|
||||
* extension.</p>
|
||||
*/
|
||||
inline const TypeConfigurationIdentifier& GetTypeConfigurationIdentifier() const{ return m_typeConfigurationIdentifier; }
|
||||
inline bool TypeConfigurationIdentifierHasBeenSet() const { return m_typeConfigurationIdentifierHasBeenSet; }
|
||||
inline void SetTypeConfigurationIdentifier(const TypeConfigurationIdentifier& value) { m_typeConfigurationIdentifierHasBeenSet = true; m_typeConfigurationIdentifier = value; }
|
||||
inline void SetTypeConfigurationIdentifier(TypeConfigurationIdentifier&& value) { m_typeConfigurationIdentifierHasBeenSet = true; m_typeConfigurationIdentifier = std::move(value); }
|
||||
inline BatchDescribeTypeConfigurationsError& WithTypeConfigurationIdentifier(const TypeConfigurationIdentifier& value) { SetTypeConfigurationIdentifier(value); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsError& WithTypeConfigurationIdentifier(TypeConfigurationIdentifier&& value) { SetTypeConfigurationIdentifier(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_errorCode;
|
||||
bool m_errorCodeHasBeenSet = false;
|
||||
|
||||
Aws::String m_errorMessage;
|
||||
bool m_errorMessageHasBeenSet = false;
|
||||
|
||||
TypeConfigurationIdentifier m_typeConfigurationIdentifier;
|
||||
bool m_typeConfigurationIdentifierHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/TypeConfigurationIdentifier.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class BatchDescribeTypeConfigurationsRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API BatchDescribeTypeConfigurationsRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "BatchDescribeTypeConfigurations"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The list of identifiers for the desired extension configurations.</p>
|
||||
*/
|
||||
inline const Aws::Vector<TypeConfigurationIdentifier>& GetTypeConfigurationIdentifiers() const{ return m_typeConfigurationIdentifiers; }
|
||||
inline bool TypeConfigurationIdentifiersHasBeenSet() const { return m_typeConfigurationIdentifiersHasBeenSet; }
|
||||
inline void SetTypeConfigurationIdentifiers(const Aws::Vector<TypeConfigurationIdentifier>& value) { m_typeConfigurationIdentifiersHasBeenSet = true; m_typeConfigurationIdentifiers = value; }
|
||||
inline void SetTypeConfigurationIdentifiers(Aws::Vector<TypeConfigurationIdentifier>&& value) { m_typeConfigurationIdentifiersHasBeenSet = true; m_typeConfigurationIdentifiers = std::move(value); }
|
||||
inline BatchDescribeTypeConfigurationsRequest& WithTypeConfigurationIdentifiers(const Aws::Vector<TypeConfigurationIdentifier>& value) { SetTypeConfigurationIdentifiers(value); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsRequest& WithTypeConfigurationIdentifiers(Aws::Vector<TypeConfigurationIdentifier>&& value) { SetTypeConfigurationIdentifiers(std::move(value)); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsRequest& AddTypeConfigurationIdentifiers(const TypeConfigurationIdentifier& value) { m_typeConfigurationIdentifiersHasBeenSet = true; m_typeConfigurationIdentifiers.push_back(value); return *this; }
|
||||
inline BatchDescribeTypeConfigurationsRequest& AddTypeConfigurationIdentifiers(TypeConfigurationIdentifier&& value) { m_typeConfigurationIdentifiersHasBeenSet = true; m_typeConfigurationIdentifiers.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<TypeConfigurationIdentifier> m_typeConfigurationIdentifiers;
|
||||
bool m_typeConfigurationIdentifiersHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,102 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <aws/cloudformation/model/BatchDescribeTypeConfigurationsError.h>
|
||||
#include <aws/cloudformation/model/TypeConfigurationIdentifier.h>
|
||||
#include <aws/cloudformation/model/TypeConfigurationDetails.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class BatchDescribeTypeConfigurationsResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API BatchDescribeTypeConfigurationsResult();
|
||||
AWS_CLOUDFORMATION_API BatchDescribeTypeConfigurationsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API BatchDescribeTypeConfigurationsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of information concerning any errors generated during the setting of
|
||||
* the specified configurations.</p>
|
||||
*/
|
||||
inline const Aws::Vector<BatchDescribeTypeConfigurationsError>& GetErrors() const{ return m_errors; }
|
||||
inline void SetErrors(const Aws::Vector<BatchDescribeTypeConfigurationsError>& value) { m_errors = value; }
|
||||
inline void SetErrors(Aws::Vector<BatchDescribeTypeConfigurationsError>&& value) { m_errors = std::move(value); }
|
||||
inline BatchDescribeTypeConfigurationsResult& WithErrors(const Aws::Vector<BatchDescribeTypeConfigurationsError>& value) { SetErrors(value); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsResult& WithErrors(Aws::Vector<BatchDescribeTypeConfigurationsError>&& value) { SetErrors(std::move(value)); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsResult& AddErrors(const BatchDescribeTypeConfigurationsError& value) { m_errors.push_back(value); return *this; }
|
||||
inline BatchDescribeTypeConfigurationsResult& AddErrors(BatchDescribeTypeConfigurationsError&& value) { m_errors.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of any of the specified extension configurations that CloudFormation
|
||||
* could not process for any reason.</p>
|
||||
*/
|
||||
inline const Aws::Vector<TypeConfigurationIdentifier>& GetUnprocessedTypeConfigurations() const{ return m_unprocessedTypeConfigurations; }
|
||||
inline void SetUnprocessedTypeConfigurations(const Aws::Vector<TypeConfigurationIdentifier>& value) { m_unprocessedTypeConfigurations = value; }
|
||||
inline void SetUnprocessedTypeConfigurations(Aws::Vector<TypeConfigurationIdentifier>&& value) { m_unprocessedTypeConfigurations = std::move(value); }
|
||||
inline BatchDescribeTypeConfigurationsResult& WithUnprocessedTypeConfigurations(const Aws::Vector<TypeConfigurationIdentifier>& value) { SetUnprocessedTypeConfigurations(value); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsResult& WithUnprocessedTypeConfigurations(Aws::Vector<TypeConfigurationIdentifier>&& value) { SetUnprocessedTypeConfigurations(std::move(value)); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsResult& AddUnprocessedTypeConfigurations(const TypeConfigurationIdentifier& value) { m_unprocessedTypeConfigurations.push_back(value); return *this; }
|
||||
inline BatchDescribeTypeConfigurationsResult& AddUnprocessedTypeConfigurations(TypeConfigurationIdentifier&& value) { m_unprocessedTypeConfigurations.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of any of the specified extension configurations from the
|
||||
* CloudFormation registry.</p>
|
||||
*/
|
||||
inline const Aws::Vector<TypeConfigurationDetails>& GetTypeConfigurations() const{ return m_typeConfigurations; }
|
||||
inline void SetTypeConfigurations(const Aws::Vector<TypeConfigurationDetails>& value) { m_typeConfigurations = value; }
|
||||
inline void SetTypeConfigurations(Aws::Vector<TypeConfigurationDetails>&& value) { m_typeConfigurations = std::move(value); }
|
||||
inline BatchDescribeTypeConfigurationsResult& WithTypeConfigurations(const Aws::Vector<TypeConfigurationDetails>& value) { SetTypeConfigurations(value); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsResult& WithTypeConfigurations(Aws::Vector<TypeConfigurationDetails>&& value) { SetTypeConfigurations(std::move(value)); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsResult& AddTypeConfigurations(const TypeConfigurationDetails& value) { m_typeConfigurations.push_back(value); return *this; }
|
||||
inline BatchDescribeTypeConfigurationsResult& AddTypeConfigurations(TypeConfigurationDetails&& value) { m_typeConfigurations.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline BatchDescribeTypeConfigurationsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline BatchDescribeTypeConfigurationsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<BatchDescribeTypeConfigurationsError> m_errors;
|
||||
|
||||
Aws::Vector<TypeConfigurationIdentifier> m_unprocessedTypeConfigurations;
|
||||
|
||||
Aws::Vector<TypeConfigurationDetails> m_typeConfigurations;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class CallAs
|
||||
{
|
||||
NOT_SET,
|
||||
SELF,
|
||||
DELEGATED_ADMIN
|
||||
};
|
||||
|
||||
namespace CallAsMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API CallAs GetCallAsForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForCallAs(CallAs value);
|
||||
} // namespace CallAsMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,92 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for the <a>CancelUpdateStack</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/CancelUpdateStackInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class CancelUpdateStackRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CancelUpdateStackRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "CancelUpdateStack"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If you don't pass a parameter to <code>StackName</code>, the API
|
||||
* returns a response that describes all resources in the account.</p> <p>The IAM
|
||||
* policy below can be added to IAM policies when you want to limit resource-level
|
||||
* permissions and avoid returning a response when no parameter is sent in the
|
||||
* request:</p> <p> <code>{ "Version": "2012-10-17", "Statement": [{ "Effect":
|
||||
* "Deny", "Action": "cloudformation:DescribeStacks", "NotResource":
|
||||
* "arn:aws:cloudformation:*:*:stack/ * / *" }] }</code> </p> <p>The name or
|
||||
* the unique stack ID that's associated with the stack.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline CancelUpdateStackRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline CancelUpdateStackRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline CancelUpdateStackRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for this <code>CancelUpdateStack</code> request. Specify
|
||||
* this token if you plan to retry requests so that CloudFormation knows that
|
||||
* you're not attempting to cancel an update on a stack with the same name. You
|
||||
* might retry <code>CancelUpdateStack</code> requests to ensure that
|
||||
* CloudFormation successfully received them.</p>
|
||||
*/
|
||||
inline const Aws::String& GetClientRequestToken() const{ return m_clientRequestToken; }
|
||||
inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
|
||||
inline void SetClientRequestToken(const Aws::String& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = value; }
|
||||
inline void SetClientRequestToken(Aws::String&& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = std::move(value); }
|
||||
inline void SetClientRequestToken(const char* value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken.assign(value); }
|
||||
inline CancelUpdateStackRequest& WithClientRequestToken(const Aws::String& value) { SetClientRequestToken(value); return *this;}
|
||||
inline CancelUpdateStackRequest& WithClientRequestToken(Aws::String&& value) { SetClientRequestToken(std::move(value)); return *this;}
|
||||
inline CancelUpdateStackRequest& WithClientRequestToken(const char* value) { SetClientRequestToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_clientRequestToken;
|
||||
bool m_clientRequestTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class Capability
|
||||
{
|
||||
NOT_SET,
|
||||
CAPABILITY_IAM,
|
||||
CAPABILITY_NAMED_IAM,
|
||||
CAPABILITY_AUTO_EXPAND
|
||||
};
|
||||
|
||||
namespace CapabilityMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API Capability GetCapabilityForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForCapability(Capability value);
|
||||
} // namespace CapabilityMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class Category
|
||||
{
|
||||
NOT_SET,
|
||||
REGISTERED,
|
||||
ACTIVATED,
|
||||
THIRD_PARTY,
|
||||
AWS_TYPES
|
||||
};
|
||||
|
||||
namespace CategoryMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API Category GetCategoryForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForCategory(Category value);
|
||||
} // namespace CategoryMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,94 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
|
||||
#include <aws/cloudformation/model/ChangeType.h>
|
||||
#include <aws/cloudformation/model/ResourceChange.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlNode;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The <code>Change</code> structure describes the changes CloudFormation will
|
||||
* perform if you execute the change set.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/Change">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class Change
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API Change();
|
||||
AWS_CLOUDFORMATION_API Change(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
AWS_CLOUDFORMATION_API Change& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type of entity that CloudFormation changes.</p> <ul> <li> <p>
|
||||
* <code>Resource</code> This change is for a resource.</p> </li> </ul>
|
||||
*/
|
||||
inline const ChangeType& GetType() const{ return m_type; }
|
||||
inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
|
||||
inline void SetType(const ChangeType& value) { m_typeHasBeenSet = true; m_type = value; }
|
||||
inline void SetType(ChangeType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
|
||||
inline Change& WithType(const ChangeType& value) { SetType(value); return *this;}
|
||||
inline Change& WithType(ChangeType&& value) { SetType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Is either <code>null</code>, if no hooks invoke for the resource, or contains
|
||||
* the number of hooks that will invoke for the resource.</p>
|
||||
*/
|
||||
inline int GetHookInvocationCount() const{ return m_hookInvocationCount; }
|
||||
inline bool HookInvocationCountHasBeenSet() const { return m_hookInvocationCountHasBeenSet; }
|
||||
inline void SetHookInvocationCount(int value) { m_hookInvocationCountHasBeenSet = true; m_hookInvocationCount = value; }
|
||||
inline Change& WithHookInvocationCount(int value) { SetHookInvocationCount(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A <code>ResourceChange</code> structure that describes the resource and
|
||||
* action that CloudFormation will perform.</p>
|
||||
*/
|
||||
inline const ResourceChange& GetResourceChange() const{ return m_resourceChange; }
|
||||
inline bool ResourceChangeHasBeenSet() const { return m_resourceChangeHasBeenSet; }
|
||||
inline void SetResourceChange(const ResourceChange& value) { m_resourceChangeHasBeenSet = true; m_resourceChange = value; }
|
||||
inline void SetResourceChange(ResourceChange&& value) { m_resourceChangeHasBeenSet = true; m_resourceChange = std::move(value); }
|
||||
inline Change& WithResourceChange(const ResourceChange& value) { SetResourceChange(value); return *this;}
|
||||
inline Change& WithResourceChange(ResourceChange&& value) { SetResourceChange(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ChangeType m_type;
|
||||
bool m_typeHasBeenSet = false;
|
||||
|
||||
int m_hookInvocationCount;
|
||||
bool m_hookInvocationCountHasBeenSet = false;
|
||||
|
||||
ResourceChange m_resourceChange;
|
||||
bool m_resourceChangeHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,34 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ChangeAction
|
||||
{
|
||||
NOT_SET,
|
||||
Add,
|
||||
Modify,
|
||||
Remove,
|
||||
Import,
|
||||
Dynamic
|
||||
};
|
||||
|
||||
namespace ChangeActionMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API ChangeAction GetChangeActionForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForChangeAction(ChangeAction value);
|
||||
} // namespace ChangeActionMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,157 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
|
||||
#include <aws/cloudformation/model/HookInvocationPoint.h>
|
||||
#include <aws/cloudformation/model/HookFailureMode.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ChangeSetHookTargetDetails.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlNode;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Specifies the resource, the hook, and the hook version to be
|
||||
* invoked.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/ChangeSetHook">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ChangeSetHook
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API ChangeSetHook();
|
||||
AWS_CLOUDFORMATION_API ChangeSetHook(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
AWS_CLOUDFORMATION_API ChangeSetHook& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Specifies the points in provisioning logic where a hook is invoked.</p>
|
||||
*/
|
||||
inline const HookInvocationPoint& GetInvocationPoint() const{ return m_invocationPoint; }
|
||||
inline bool InvocationPointHasBeenSet() const { return m_invocationPointHasBeenSet; }
|
||||
inline void SetInvocationPoint(const HookInvocationPoint& value) { m_invocationPointHasBeenSet = true; m_invocationPoint = value; }
|
||||
inline void SetInvocationPoint(HookInvocationPoint&& value) { m_invocationPointHasBeenSet = true; m_invocationPoint = std::move(value); }
|
||||
inline ChangeSetHook& WithInvocationPoint(const HookInvocationPoint& value) { SetInvocationPoint(value); return *this;}
|
||||
inline ChangeSetHook& WithInvocationPoint(HookInvocationPoint&& value) { SetInvocationPoint(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Specify the hook failure mode for non-compliant resources in the followings
|
||||
* ways.</p> <ul> <li> <p> <code>FAIL</code> Stops provisioning resources.</p>
|
||||
* </li> <li> <p> <code>WARN</code> Allows provisioning to continue with a warning
|
||||
* message.</p> </li> </ul>
|
||||
*/
|
||||
inline const HookFailureMode& GetFailureMode() const{ return m_failureMode; }
|
||||
inline bool FailureModeHasBeenSet() const { return m_failureModeHasBeenSet; }
|
||||
inline void SetFailureMode(const HookFailureMode& value) { m_failureModeHasBeenSet = true; m_failureMode = value; }
|
||||
inline void SetFailureMode(HookFailureMode&& value) { m_failureModeHasBeenSet = true; m_failureMode = std::move(value); }
|
||||
inline ChangeSetHook& WithFailureMode(const HookFailureMode& value) { SetFailureMode(value); return *this;}
|
||||
inline ChangeSetHook& WithFailureMode(HookFailureMode&& value) { SetFailureMode(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique name for your hook. Specifies a three-part namespace for your
|
||||
* hook, with a recommended pattern of
|
||||
* <code>Organization::Service::Hook</code>.</p> <p>The following
|
||||
* organization namespaces are reserved and can't be used in your hook type
|
||||
* names:</p> <ul> <li> <p> <code>Alexa</code> </p> </li> <li> <p>
|
||||
* <code>AMZN</code> </p> </li> <li> <p> <code>Amazon</code> </p> </li> <li> <p>
|
||||
* <code>ASK</code> </p> </li> <li> <p> <code>AWS</code> </p> </li> <li> <p>
|
||||
* <code>Custom</code> </p> </li> <li> <p> <code>Dev</code> </p> </li> </ul>
|
||||
*
|
||||
*/
|
||||
inline const Aws::String& GetTypeName() const{ return m_typeName; }
|
||||
inline bool TypeNameHasBeenSet() const { return m_typeNameHasBeenSet; }
|
||||
inline void SetTypeName(const Aws::String& value) { m_typeNameHasBeenSet = true; m_typeName = value; }
|
||||
inline void SetTypeName(Aws::String&& value) { m_typeNameHasBeenSet = true; m_typeName = std::move(value); }
|
||||
inline void SetTypeName(const char* value) { m_typeNameHasBeenSet = true; m_typeName.assign(value); }
|
||||
inline ChangeSetHook& WithTypeName(const Aws::String& value) { SetTypeName(value); return *this;}
|
||||
inline ChangeSetHook& WithTypeName(Aws::String&& value) { SetTypeName(std::move(value)); return *this;}
|
||||
inline ChangeSetHook& WithTypeName(const char* value) { SetTypeName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The version ID of the type specified.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTypeVersionId() const{ return m_typeVersionId; }
|
||||
inline bool TypeVersionIdHasBeenSet() const { return m_typeVersionIdHasBeenSet; }
|
||||
inline void SetTypeVersionId(const Aws::String& value) { m_typeVersionIdHasBeenSet = true; m_typeVersionId = value; }
|
||||
inline void SetTypeVersionId(Aws::String&& value) { m_typeVersionIdHasBeenSet = true; m_typeVersionId = std::move(value); }
|
||||
inline void SetTypeVersionId(const char* value) { m_typeVersionIdHasBeenSet = true; m_typeVersionId.assign(value); }
|
||||
inline ChangeSetHook& WithTypeVersionId(const Aws::String& value) { SetTypeVersionId(value); return *this;}
|
||||
inline ChangeSetHook& WithTypeVersionId(Aws::String&& value) { SetTypeVersionId(std::move(value)); return *this;}
|
||||
inline ChangeSetHook& WithTypeVersionId(const char* value) { SetTypeVersionId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The version ID of the type configuration.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTypeConfigurationVersionId() const{ return m_typeConfigurationVersionId; }
|
||||
inline bool TypeConfigurationVersionIdHasBeenSet() const { return m_typeConfigurationVersionIdHasBeenSet; }
|
||||
inline void SetTypeConfigurationVersionId(const Aws::String& value) { m_typeConfigurationVersionIdHasBeenSet = true; m_typeConfigurationVersionId = value; }
|
||||
inline void SetTypeConfigurationVersionId(Aws::String&& value) { m_typeConfigurationVersionIdHasBeenSet = true; m_typeConfigurationVersionId = std::move(value); }
|
||||
inline void SetTypeConfigurationVersionId(const char* value) { m_typeConfigurationVersionIdHasBeenSet = true; m_typeConfigurationVersionId.assign(value); }
|
||||
inline ChangeSetHook& WithTypeConfigurationVersionId(const Aws::String& value) { SetTypeConfigurationVersionId(value); return *this;}
|
||||
inline ChangeSetHook& WithTypeConfigurationVersionId(Aws::String&& value) { SetTypeConfigurationVersionId(std::move(value)); return *this;}
|
||||
inline ChangeSetHook& WithTypeConfigurationVersionId(const char* value) { SetTypeConfigurationVersionId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Specifies details about the target that the hook will run against.</p>
|
||||
*/
|
||||
inline const ChangeSetHookTargetDetails& GetTargetDetails() const{ return m_targetDetails; }
|
||||
inline bool TargetDetailsHasBeenSet() const { return m_targetDetailsHasBeenSet; }
|
||||
inline void SetTargetDetails(const ChangeSetHookTargetDetails& value) { m_targetDetailsHasBeenSet = true; m_targetDetails = value; }
|
||||
inline void SetTargetDetails(ChangeSetHookTargetDetails&& value) { m_targetDetailsHasBeenSet = true; m_targetDetails = std::move(value); }
|
||||
inline ChangeSetHook& WithTargetDetails(const ChangeSetHookTargetDetails& value) { SetTargetDetails(value); return *this;}
|
||||
inline ChangeSetHook& WithTargetDetails(ChangeSetHookTargetDetails&& value) { SetTargetDetails(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
HookInvocationPoint m_invocationPoint;
|
||||
bool m_invocationPointHasBeenSet = false;
|
||||
|
||||
HookFailureMode m_failureMode;
|
||||
bool m_failureModeHasBeenSet = false;
|
||||
|
||||
Aws::String m_typeName;
|
||||
bool m_typeNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_typeVersionId;
|
||||
bool m_typeVersionIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_typeConfigurationVersionId;
|
||||
bool m_typeConfigurationVersionIdHasBeenSet = false;
|
||||
|
||||
ChangeSetHookTargetDetails m_targetDetails;
|
||||
bool m_targetDetailsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ChangeAction.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlNode;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Specifies <code>RESOURCE</code> type target details for activated
|
||||
* hooks.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/ChangeSetHookResourceTargetDetails">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ChangeSetHookResourceTargetDetails
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API ChangeSetHookResourceTargetDetails();
|
||||
AWS_CLOUDFORMATION_API ChangeSetHookResourceTargetDetails(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
AWS_CLOUDFORMATION_API ChangeSetHookResourceTargetDetails& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The resource's logical ID, which is defined in the stack's template.</p>
|
||||
*/
|
||||
inline const Aws::String& GetLogicalResourceId() const{ return m_logicalResourceId; }
|
||||
inline bool LogicalResourceIdHasBeenSet() const { return m_logicalResourceIdHasBeenSet; }
|
||||
inline void SetLogicalResourceId(const Aws::String& value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId = value; }
|
||||
inline void SetLogicalResourceId(Aws::String&& value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId = std::move(value); }
|
||||
inline void SetLogicalResourceId(const char* value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId.assign(value); }
|
||||
inline ChangeSetHookResourceTargetDetails& WithLogicalResourceId(const Aws::String& value) { SetLogicalResourceId(value); return *this;}
|
||||
inline ChangeSetHookResourceTargetDetails& WithLogicalResourceId(Aws::String&& value) { SetLogicalResourceId(std::move(value)); return *this;}
|
||||
inline ChangeSetHookResourceTargetDetails& WithLogicalResourceId(const char* value) { SetLogicalResourceId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type of CloudFormation resource, such as
|
||||
* <code>AWS::S3::Bucket</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetResourceType() const{ return m_resourceType; }
|
||||
inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
|
||||
inline void SetResourceType(const Aws::String& value) { m_resourceTypeHasBeenSet = true; m_resourceType = value; }
|
||||
inline void SetResourceType(Aws::String&& value) { m_resourceTypeHasBeenSet = true; m_resourceType = std::move(value); }
|
||||
inline void SetResourceType(const char* value) { m_resourceTypeHasBeenSet = true; m_resourceType.assign(value); }
|
||||
inline ChangeSetHookResourceTargetDetails& WithResourceType(const Aws::String& value) { SetResourceType(value); return *this;}
|
||||
inline ChangeSetHookResourceTargetDetails& WithResourceType(Aws::String&& value) { SetResourceType(std::move(value)); return *this;}
|
||||
inline ChangeSetHookResourceTargetDetails& WithResourceType(const char* value) { SetResourceType(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Specifies the action of the resource.</p>
|
||||
*/
|
||||
inline const ChangeAction& GetResourceAction() const{ return m_resourceAction; }
|
||||
inline bool ResourceActionHasBeenSet() const { return m_resourceActionHasBeenSet; }
|
||||
inline void SetResourceAction(const ChangeAction& value) { m_resourceActionHasBeenSet = true; m_resourceAction = value; }
|
||||
inline void SetResourceAction(ChangeAction&& value) { m_resourceActionHasBeenSet = true; m_resourceAction = std::move(value); }
|
||||
inline ChangeSetHookResourceTargetDetails& WithResourceAction(const ChangeAction& value) { SetResourceAction(value); return *this;}
|
||||
inline ChangeSetHookResourceTargetDetails& WithResourceAction(ChangeAction&& value) { SetResourceAction(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_logicalResourceId;
|
||||
bool m_logicalResourceIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_resourceType;
|
||||
bool m_resourceTypeHasBeenSet = false;
|
||||
|
||||
ChangeAction m_resourceAction;
|
||||
bool m_resourceActionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,77 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
|
||||
#include <aws/cloudformation/model/HookTargetType.h>
|
||||
#include <aws/cloudformation/model/ChangeSetHookResourceTargetDetails.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlNode;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Specifies target details for an activated hook.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/ChangeSetHookTargetDetails">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ChangeSetHookTargetDetails
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API ChangeSetHookTargetDetails();
|
||||
AWS_CLOUDFORMATION_API ChangeSetHookTargetDetails(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
AWS_CLOUDFORMATION_API ChangeSetHookTargetDetails& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the type.</p>
|
||||
*/
|
||||
inline const HookTargetType& GetTargetType() const{ return m_targetType; }
|
||||
inline bool TargetTypeHasBeenSet() const { return m_targetTypeHasBeenSet; }
|
||||
inline void SetTargetType(const HookTargetType& value) { m_targetTypeHasBeenSet = true; m_targetType = value; }
|
||||
inline void SetTargetType(HookTargetType&& value) { m_targetTypeHasBeenSet = true; m_targetType = std::move(value); }
|
||||
inline ChangeSetHookTargetDetails& WithTargetType(const HookTargetType& value) { SetTargetType(value); return *this;}
|
||||
inline ChangeSetHookTargetDetails& WithTargetType(HookTargetType&& value) { SetTargetType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Required if <code>TargetType</code> is <code>RESOURCE</code>.</p>
|
||||
*/
|
||||
inline const ChangeSetHookResourceTargetDetails& GetResourceTargetDetails() const{ return m_resourceTargetDetails; }
|
||||
inline bool ResourceTargetDetailsHasBeenSet() const { return m_resourceTargetDetailsHasBeenSet; }
|
||||
inline void SetResourceTargetDetails(const ChangeSetHookResourceTargetDetails& value) { m_resourceTargetDetailsHasBeenSet = true; m_resourceTargetDetails = value; }
|
||||
inline void SetResourceTargetDetails(ChangeSetHookResourceTargetDetails&& value) { m_resourceTargetDetailsHasBeenSet = true; m_resourceTargetDetails = std::move(value); }
|
||||
inline ChangeSetHookTargetDetails& WithResourceTargetDetails(const ChangeSetHookResourceTargetDetails& value) { SetResourceTargetDetails(value); return *this;}
|
||||
inline ChangeSetHookTargetDetails& WithResourceTargetDetails(ChangeSetHookResourceTargetDetails&& value) { SetResourceTargetDetails(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
HookTargetType m_targetType;
|
||||
bool m_targetTypeHasBeenSet = false;
|
||||
|
||||
ChangeSetHookResourceTargetDetails m_resourceTargetDetails;
|
||||
bool m_resourceTargetDetailsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ChangeSetHooksStatus
|
||||
{
|
||||
NOT_SET,
|
||||
PLANNING,
|
||||
PLANNED,
|
||||
UNAVAILABLE
|
||||
};
|
||||
|
||||
namespace ChangeSetHooksStatusMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API ChangeSetHooksStatus GetChangeSetHooksStatusForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForChangeSetHooksStatus(ChangeSetHooksStatus value);
|
||||
} // namespace ChangeSetHooksStatusMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ChangeSetStatus
|
||||
{
|
||||
NOT_SET,
|
||||
CREATE_PENDING,
|
||||
CREATE_IN_PROGRESS,
|
||||
CREATE_COMPLETE,
|
||||
DELETE_PENDING,
|
||||
DELETE_IN_PROGRESS,
|
||||
DELETE_COMPLETE,
|
||||
DELETE_FAILED,
|
||||
FAILED
|
||||
};
|
||||
|
||||
namespace ChangeSetStatusMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API ChangeSetStatus GetChangeSetStatusForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForChangeSetStatus(ChangeSetStatus value);
|
||||
} // namespace ChangeSetStatusMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,264 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ExecutionStatus.h>
|
||||
#include <aws/cloudformation/model/ChangeSetStatus.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlNode;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The <code>ChangeSetSummary</code> structure describes a change set, its
|
||||
* status, and the stack with which it's associated.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/ChangeSetSummary">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ChangeSetSummary
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API ChangeSetSummary();
|
||||
AWS_CLOUDFORMATION_API ChangeSetSummary(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
AWS_CLOUDFORMATION_API ChangeSetSummary& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the stack with which the change set is associated.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackId() const{ return m_stackId; }
|
||||
inline bool StackIdHasBeenSet() const { return m_stackIdHasBeenSet; }
|
||||
inline void SetStackId(const Aws::String& value) { m_stackIdHasBeenSet = true; m_stackId = value; }
|
||||
inline void SetStackId(Aws::String&& value) { m_stackIdHasBeenSet = true; m_stackId = std::move(value); }
|
||||
inline void SetStackId(const char* value) { m_stackIdHasBeenSet = true; m_stackId.assign(value); }
|
||||
inline ChangeSetSummary& WithStackId(const Aws::String& value) { SetStackId(value); return *this;}
|
||||
inline ChangeSetSummary& WithStackId(Aws::String&& value) { SetStackId(std::move(value)); return *this;}
|
||||
inline ChangeSetSummary& WithStackId(const char* value) { SetStackId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the stack with which the change set is associated.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline ChangeSetSummary& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline ChangeSetSummary& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline ChangeSetSummary& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the change set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetChangeSetId() const{ return m_changeSetId; }
|
||||
inline bool ChangeSetIdHasBeenSet() const { return m_changeSetIdHasBeenSet; }
|
||||
inline void SetChangeSetId(const Aws::String& value) { m_changeSetIdHasBeenSet = true; m_changeSetId = value; }
|
||||
inline void SetChangeSetId(Aws::String&& value) { m_changeSetIdHasBeenSet = true; m_changeSetId = std::move(value); }
|
||||
inline void SetChangeSetId(const char* value) { m_changeSetIdHasBeenSet = true; m_changeSetId.assign(value); }
|
||||
inline ChangeSetSummary& WithChangeSetId(const Aws::String& value) { SetChangeSetId(value); return *this;}
|
||||
inline ChangeSetSummary& WithChangeSetId(Aws::String&& value) { SetChangeSetId(std::move(value)); return *this;}
|
||||
inline ChangeSetSummary& WithChangeSetId(const char* value) { SetChangeSetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the change set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetChangeSetName() const{ return m_changeSetName; }
|
||||
inline bool ChangeSetNameHasBeenSet() const { return m_changeSetNameHasBeenSet; }
|
||||
inline void SetChangeSetName(const Aws::String& value) { m_changeSetNameHasBeenSet = true; m_changeSetName = value; }
|
||||
inline void SetChangeSetName(Aws::String&& value) { m_changeSetNameHasBeenSet = true; m_changeSetName = std::move(value); }
|
||||
inline void SetChangeSetName(const char* value) { m_changeSetNameHasBeenSet = true; m_changeSetName.assign(value); }
|
||||
inline ChangeSetSummary& WithChangeSetName(const Aws::String& value) { SetChangeSetName(value); return *this;}
|
||||
inline ChangeSetSummary& WithChangeSetName(Aws::String&& value) { SetChangeSetName(std::move(value)); return *this;}
|
||||
inline ChangeSetSummary& WithChangeSetName(const char* value) { SetChangeSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If the change set execution status is <code>AVAILABLE</code>, you can execute
|
||||
* the change set. If you can't execute the change set, the status indicates why.
|
||||
* For example, a change set might be in an <code>UNAVAILABLE</code> state because
|
||||
* CloudFormation is still creating it or in an <code>OBSOLETE</code> state because
|
||||
* the stack was already updated.</p>
|
||||
*/
|
||||
inline const ExecutionStatus& GetExecutionStatus() const{ return m_executionStatus; }
|
||||
inline bool ExecutionStatusHasBeenSet() const { return m_executionStatusHasBeenSet; }
|
||||
inline void SetExecutionStatus(const ExecutionStatus& value) { m_executionStatusHasBeenSet = true; m_executionStatus = value; }
|
||||
inline void SetExecutionStatus(ExecutionStatus&& value) { m_executionStatusHasBeenSet = true; m_executionStatus = std::move(value); }
|
||||
inline ChangeSetSummary& WithExecutionStatus(const ExecutionStatus& value) { SetExecutionStatus(value); return *this;}
|
||||
inline ChangeSetSummary& WithExecutionStatus(ExecutionStatus&& value) { SetExecutionStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The state of the change set, such as <code>CREATE_IN_PROGRESS</code>,
|
||||
* <code>CREATE_COMPLETE</code>, or <code>FAILED</code>.</p>
|
||||
*/
|
||||
inline const ChangeSetStatus& GetStatus() const{ return m_status; }
|
||||
inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
|
||||
inline void SetStatus(const ChangeSetStatus& value) { m_statusHasBeenSet = true; m_status = value; }
|
||||
inline void SetStatus(ChangeSetStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
|
||||
inline ChangeSetSummary& WithStatus(const ChangeSetStatus& value) { SetStatus(value); return *this;}
|
||||
inline ChangeSetSummary& WithStatus(ChangeSetStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A description of the change set's status. For example, if your change set is
|
||||
* in the <code>FAILED</code> state, CloudFormation shows the error message.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStatusReason() const{ return m_statusReason; }
|
||||
inline bool StatusReasonHasBeenSet() const { return m_statusReasonHasBeenSet; }
|
||||
inline void SetStatusReason(const Aws::String& value) { m_statusReasonHasBeenSet = true; m_statusReason = value; }
|
||||
inline void SetStatusReason(Aws::String&& value) { m_statusReasonHasBeenSet = true; m_statusReason = std::move(value); }
|
||||
inline void SetStatusReason(const char* value) { m_statusReasonHasBeenSet = true; m_statusReason.assign(value); }
|
||||
inline ChangeSetSummary& WithStatusReason(const Aws::String& value) { SetStatusReason(value); return *this;}
|
||||
inline ChangeSetSummary& WithStatusReason(Aws::String&& value) { SetStatusReason(std::move(value)); return *this;}
|
||||
inline ChangeSetSummary& WithStatusReason(const char* value) { SetStatusReason(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The start time when the change set was created, in UTC.</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
|
||||
inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
|
||||
inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
|
||||
inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
|
||||
inline ChangeSetSummary& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
|
||||
inline ChangeSetSummary& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Descriptive information about the change set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
|
||||
inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
|
||||
inline ChangeSetSummary& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline ChangeSetSummary& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline ChangeSetSummary& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Specifies the current setting of <code>IncludeNestedStacks</code> for the
|
||||
* change set.</p>
|
||||
*/
|
||||
inline bool GetIncludeNestedStacks() const{ return m_includeNestedStacks; }
|
||||
inline bool IncludeNestedStacksHasBeenSet() const { return m_includeNestedStacksHasBeenSet; }
|
||||
inline void SetIncludeNestedStacks(bool value) { m_includeNestedStacksHasBeenSet = true; m_includeNestedStacks = value; }
|
||||
inline ChangeSetSummary& WithIncludeNestedStacks(bool value) { SetIncludeNestedStacks(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The parent change set ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetParentChangeSetId() const{ return m_parentChangeSetId; }
|
||||
inline bool ParentChangeSetIdHasBeenSet() const { return m_parentChangeSetIdHasBeenSet; }
|
||||
inline void SetParentChangeSetId(const Aws::String& value) { m_parentChangeSetIdHasBeenSet = true; m_parentChangeSetId = value; }
|
||||
inline void SetParentChangeSetId(Aws::String&& value) { m_parentChangeSetIdHasBeenSet = true; m_parentChangeSetId = std::move(value); }
|
||||
inline void SetParentChangeSetId(const char* value) { m_parentChangeSetIdHasBeenSet = true; m_parentChangeSetId.assign(value); }
|
||||
inline ChangeSetSummary& WithParentChangeSetId(const Aws::String& value) { SetParentChangeSetId(value); return *this;}
|
||||
inline ChangeSetSummary& WithParentChangeSetId(Aws::String&& value) { SetParentChangeSetId(std::move(value)); return *this;}
|
||||
inline ChangeSetSummary& WithParentChangeSetId(const char* value) { SetParentChangeSetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The root change set ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRootChangeSetId() const{ return m_rootChangeSetId; }
|
||||
inline bool RootChangeSetIdHasBeenSet() const { return m_rootChangeSetIdHasBeenSet; }
|
||||
inline void SetRootChangeSetId(const Aws::String& value) { m_rootChangeSetIdHasBeenSet = true; m_rootChangeSetId = value; }
|
||||
inline void SetRootChangeSetId(Aws::String&& value) { m_rootChangeSetIdHasBeenSet = true; m_rootChangeSetId = std::move(value); }
|
||||
inline void SetRootChangeSetId(const char* value) { m_rootChangeSetIdHasBeenSet = true; m_rootChangeSetId.assign(value); }
|
||||
inline ChangeSetSummary& WithRootChangeSetId(const Aws::String& value) { SetRootChangeSetId(value); return *this;}
|
||||
inline ChangeSetSummary& WithRootChangeSetId(Aws::String&& value) { SetRootChangeSetId(std::move(value)); return *this;}
|
||||
inline ChangeSetSummary& WithRootChangeSetId(const char* value) { SetRootChangeSetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates if the change set imports resources that already exist.</p>
|
||||
*/
|
||||
inline bool GetImportExistingResources() const{ return m_importExistingResources; }
|
||||
inline bool ImportExistingResourcesHasBeenSet() const { return m_importExistingResourcesHasBeenSet; }
|
||||
inline void SetImportExistingResources(bool value) { m_importExistingResourcesHasBeenSet = true; m_importExistingResources = value; }
|
||||
inline ChangeSetSummary& WithImportExistingResources(bool value) { SetImportExistingResources(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackId;
|
||||
bool m_stackIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_changeSetId;
|
||||
bool m_changeSetIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_changeSetName;
|
||||
bool m_changeSetNameHasBeenSet = false;
|
||||
|
||||
ExecutionStatus m_executionStatus;
|
||||
bool m_executionStatusHasBeenSet = false;
|
||||
|
||||
ChangeSetStatus m_status;
|
||||
bool m_statusHasBeenSet = false;
|
||||
|
||||
Aws::String m_statusReason;
|
||||
bool m_statusReasonHasBeenSet = false;
|
||||
|
||||
Aws::Utils::DateTime m_creationTime;
|
||||
bool m_creationTimeHasBeenSet = false;
|
||||
|
||||
Aws::String m_description;
|
||||
bool m_descriptionHasBeenSet = false;
|
||||
|
||||
bool m_includeNestedStacks;
|
||||
bool m_includeNestedStacksHasBeenSet = false;
|
||||
|
||||
Aws::String m_parentChangeSetId;
|
||||
bool m_parentChangeSetIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_rootChangeSetId;
|
||||
bool m_rootChangeSetIdHasBeenSet = false;
|
||||
|
||||
bool m_importExistingResources;
|
||||
bool m_importExistingResourcesHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ChangeSetType
|
||||
{
|
||||
NOT_SET,
|
||||
CREATE,
|
||||
UPDATE,
|
||||
IMPORT
|
||||
};
|
||||
|
||||
namespace ChangeSetTypeMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API ChangeSetType GetChangeSetTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForChangeSetType(ChangeSetType value);
|
||||
} // namespace ChangeSetTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,34 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ChangeSource
|
||||
{
|
||||
NOT_SET,
|
||||
ResourceReference,
|
||||
ParameterReference,
|
||||
ResourceAttribute,
|
||||
DirectModification,
|
||||
Automatic
|
||||
};
|
||||
|
||||
namespace ChangeSourceMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API ChangeSource GetChangeSourceForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForChangeSource(ChangeSource value);
|
||||
} // namespace ChangeSourceMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,30 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ChangeType
|
||||
{
|
||||
NOT_SET,
|
||||
Resource
|
||||
};
|
||||
|
||||
namespace ChangeTypeMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API ChangeType GetChangeTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForChangeType(ChangeType value);
|
||||
} // namespace ChangeTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ConcurrencyMode
|
||||
{
|
||||
NOT_SET,
|
||||
STRICT_FAILURE_TOLERANCE,
|
||||
SOFT_FAILURE_TOLERANCE
|
||||
};
|
||||
|
||||
namespace ConcurrencyModeMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API ConcurrencyMode GetConcurrencyModeForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForConcurrencyMode(ConcurrencyMode value);
|
||||
} // namespace ConcurrencyModeMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,163 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for the <a>ContinueUpdateRollback</a> action.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/ContinueUpdateRollbackInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContinueUpdateRollbackRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API ContinueUpdateRollbackRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "ContinueUpdateRollback"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or the unique ID of the stack that you want to continue rolling
|
||||
* back.</p> <p>Don't specify the name of a nested stack (a stack that was
|
||||
* created by using the <code>AWS::CloudFormation::Stack</code> resource). Instead,
|
||||
* use this operation on the parent stack (the stack that contains the
|
||||
* <code>AWS::CloudFormation::Stack</code> resource).</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline ContinueUpdateRollbackRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline ContinueUpdateRollbackRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline ContinueUpdateRollbackRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of an IAM role that CloudFormation assumes to
|
||||
* roll back the stack. CloudFormation uses the role's credentials to make calls on
|
||||
* your behalf. CloudFormation always uses this role for all future operations on
|
||||
* the stack. Provided that users have permission to operate on the stack,
|
||||
* CloudFormation uses this role even if the users don't have permission to pass
|
||||
* it. Ensure that the role grants least permission.</p> <p>If you don't specify a
|
||||
* value, CloudFormation uses the role that was previously associated with the
|
||||
* stack. If no role is available, CloudFormation uses a temporary session that's
|
||||
* generated from your user credentials.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRoleARN() const{ return m_roleARN; }
|
||||
inline bool RoleARNHasBeenSet() const { return m_roleARNHasBeenSet; }
|
||||
inline void SetRoleARN(const Aws::String& value) { m_roleARNHasBeenSet = true; m_roleARN = value; }
|
||||
inline void SetRoleARN(Aws::String&& value) { m_roleARNHasBeenSet = true; m_roleARN = std::move(value); }
|
||||
inline void SetRoleARN(const char* value) { m_roleARNHasBeenSet = true; m_roleARN.assign(value); }
|
||||
inline ContinueUpdateRollbackRequest& WithRoleARN(const Aws::String& value) { SetRoleARN(value); return *this;}
|
||||
inline ContinueUpdateRollbackRequest& WithRoleARN(Aws::String&& value) { SetRoleARN(std::move(value)); return *this;}
|
||||
inline ContinueUpdateRollbackRequest& WithRoleARN(const char* value) { SetRoleARN(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of the logical IDs of the resources that CloudFormation skips during
|
||||
* the continue update rollback operation. You can specify only resources that are
|
||||
* in the <code>UPDATE_FAILED</code> state because a rollback failed. You can't
|
||||
* specify resources that are in the <code>UPDATE_FAILED</code> state for other
|
||||
* reasons, for example, because an update was canceled. To check why a resource
|
||||
* update failed, use the <a>DescribeStackResources</a> action, and view the
|
||||
* resource status reason.</p> <p>Specify this property to skip rolling
|
||||
* back resources that CloudFormation can't successfully roll back. We recommend
|
||||
* that you <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/troubleshooting.html#troubleshooting-errors-update-rollback-failed">
|
||||
* troubleshoot</a> resources before skipping them. CloudFormation sets the status
|
||||
* of the specified resources to <code>UPDATE_COMPLETE</code> and continues to roll
|
||||
* back the stack. After the rollback is complete, the state of the skipped
|
||||
* resources will be inconsistent with the state of the resources in the stack
|
||||
* template. Before performing another stack update, you must update the stack or
|
||||
* resources to be consistent with each other. If you don't, subsequent stack
|
||||
* updates might fail, and the stack will become unrecoverable.</p>
|
||||
* <p>Specify the minimum number of resources required to successfully roll back
|
||||
* your stack. For example, a failed resource update might cause dependent
|
||||
* resources to fail. In this case, it might not be necessary to skip the dependent
|
||||
* resources.</p> <p>To skip resources that are part of nested stacks, use the
|
||||
* following format: <code>NestedStackName.ResourceLogicalID</code>. If you want to
|
||||
* specify the logical ID of a stack resource (<code>Type:
|
||||
* AWS::CloudFormation::Stack</code>) in the <code>ResourcesToSkip</code> list,
|
||||
* then its corresponding embedded stack must be in one of the following states:
|
||||
* <code>DELETE_IN_PROGRESS</code>, <code>DELETE_COMPLETE</code>, or
|
||||
* <code>DELETE_FAILED</code>.</p> <p>Don't confuse a child stack's name
|
||||
* with its corresponding logical ID defined in the parent stack. For an example of
|
||||
* a continue update rollback operation with nested stacks, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-continueupdaterollback.html#nested-stacks">Continue
|
||||
* rolling back from failed nested stack updates</a>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetResourcesToSkip() const{ return m_resourcesToSkip; }
|
||||
inline bool ResourcesToSkipHasBeenSet() const { return m_resourcesToSkipHasBeenSet; }
|
||||
inline void SetResourcesToSkip(const Aws::Vector<Aws::String>& value) { m_resourcesToSkipHasBeenSet = true; m_resourcesToSkip = value; }
|
||||
inline void SetResourcesToSkip(Aws::Vector<Aws::String>&& value) { m_resourcesToSkipHasBeenSet = true; m_resourcesToSkip = std::move(value); }
|
||||
inline ContinueUpdateRollbackRequest& WithResourcesToSkip(const Aws::Vector<Aws::String>& value) { SetResourcesToSkip(value); return *this;}
|
||||
inline ContinueUpdateRollbackRequest& WithResourcesToSkip(Aws::Vector<Aws::String>&& value) { SetResourcesToSkip(std::move(value)); return *this;}
|
||||
inline ContinueUpdateRollbackRequest& AddResourcesToSkip(const Aws::String& value) { m_resourcesToSkipHasBeenSet = true; m_resourcesToSkip.push_back(value); return *this; }
|
||||
inline ContinueUpdateRollbackRequest& AddResourcesToSkip(Aws::String&& value) { m_resourcesToSkipHasBeenSet = true; m_resourcesToSkip.push_back(std::move(value)); return *this; }
|
||||
inline ContinueUpdateRollbackRequest& AddResourcesToSkip(const char* value) { m_resourcesToSkipHasBeenSet = true; m_resourcesToSkip.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for this <code>ContinueUpdateRollback</code> request.
|
||||
* Specify this token if you plan to retry requests so that CloudFormation knows
|
||||
* that you're not attempting to continue the rollback to a stack with the same
|
||||
* name. You might retry <code>ContinueUpdateRollback</code> requests to ensure
|
||||
* that CloudFormation successfully received them.</p>
|
||||
*/
|
||||
inline const Aws::String& GetClientRequestToken() const{ return m_clientRequestToken; }
|
||||
inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
|
||||
inline void SetClientRequestToken(const Aws::String& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = value; }
|
||||
inline void SetClientRequestToken(Aws::String&& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = std::move(value); }
|
||||
inline void SetClientRequestToken(const char* value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken.assign(value); }
|
||||
inline ContinueUpdateRollbackRequest& WithClientRequestToken(const Aws::String& value) { SetClientRequestToken(value); return *this;}
|
||||
inline ContinueUpdateRollbackRequest& WithClientRequestToken(Aws::String&& value) { SetClientRequestToken(std::move(value)); return *this;}
|
||||
inline ContinueUpdateRollbackRequest& WithClientRequestToken(const char* value) { SetClientRequestToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_roleARN;
|
||||
bool m_roleARNHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_resourcesToSkip;
|
||||
bool m_resourcesToSkipHasBeenSet = false;
|
||||
|
||||
Aws::String m_clientRequestToken;
|
||||
bool m_clientRequestTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,56 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The output for a <a>ContinueUpdateRollback</a> operation.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/ContinueUpdateRollbackOutput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContinueUpdateRollbackResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API ContinueUpdateRollbackResult();
|
||||
AWS_CLOUDFORMATION_API ContinueUpdateRollbackResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API ContinueUpdateRollbackResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline ContinueUpdateRollbackResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline ContinueUpdateRollbackResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,498 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/RollbackConfiguration.h>
|
||||
#include <aws/cloudformation/model/ChangeSetType.h>
|
||||
#include <aws/cloudformation/model/OnStackFailure.h>
|
||||
#include <aws/cloudformation/model/Parameter.h>
|
||||
#include <aws/cloudformation/model/Capability.h>
|
||||
#include <aws/cloudformation/model/Tag.h>
|
||||
#include <aws/cloudformation/model/ResourceToImport.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for the <a>CreateChangeSet</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/CreateChangeSetInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class CreateChangeSetRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CreateChangeSetRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "CreateChangeSet"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or the unique ID of the stack for which you are creating a change
|
||||
* set. CloudFormation generates the change set by comparing this stack's
|
||||
* information with the information that you submit, such as a modified template or
|
||||
* different parameter input values.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline CreateChangeSetRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A structure that contains the body of the revised template, with a minimum
|
||||
* length of 1 byte and a maximum length of 51,200 bytes. CloudFormation generates
|
||||
* the change set by comparing this template with the template of the stack that
|
||||
* you specified.</p> <p>Conditional: You must specify only
|
||||
* <code>TemplateBody</code> or <code>TemplateURL</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTemplateBody() const{ return m_templateBody; }
|
||||
inline bool TemplateBodyHasBeenSet() const { return m_templateBodyHasBeenSet; }
|
||||
inline void SetTemplateBody(const Aws::String& value) { m_templateBodyHasBeenSet = true; m_templateBody = value; }
|
||||
inline void SetTemplateBody(Aws::String&& value) { m_templateBodyHasBeenSet = true; m_templateBody = std::move(value); }
|
||||
inline void SetTemplateBody(const char* value) { m_templateBodyHasBeenSet = true; m_templateBody.assign(value); }
|
||||
inline CreateChangeSetRequest& WithTemplateBody(const Aws::String& value) { SetTemplateBody(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithTemplateBody(Aws::String&& value) { SetTemplateBody(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& WithTemplateBody(const char* value) { SetTemplateBody(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The location of the file that contains the revised template. The URL must
|
||||
* point to a template (max size: 460,800 bytes) that's located in an Amazon S3
|
||||
* bucket or a Systems Manager document. CloudFormation generates the change set by
|
||||
* comparing this template with the stack that you specified. The location for an
|
||||
* Amazon S3 bucket must start with <code>https://</code>.</p> <p>Conditional: You
|
||||
* must specify only <code>TemplateBody</code> or <code>TemplateURL</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTemplateURL() const{ return m_templateURL; }
|
||||
inline bool TemplateURLHasBeenSet() const { return m_templateURLHasBeenSet; }
|
||||
inline void SetTemplateURL(const Aws::String& value) { m_templateURLHasBeenSet = true; m_templateURL = value; }
|
||||
inline void SetTemplateURL(Aws::String&& value) { m_templateURLHasBeenSet = true; m_templateURL = std::move(value); }
|
||||
inline void SetTemplateURL(const char* value) { m_templateURLHasBeenSet = true; m_templateURL.assign(value); }
|
||||
inline CreateChangeSetRequest& WithTemplateURL(const Aws::String& value) { SetTemplateURL(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithTemplateURL(Aws::String&& value) { SetTemplateURL(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& WithTemplateURL(const char* value) { SetTemplateURL(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Whether to reuse the template that's associated with the stack to create the
|
||||
* change set.</p>
|
||||
*/
|
||||
inline bool GetUsePreviousTemplate() const{ return m_usePreviousTemplate; }
|
||||
inline bool UsePreviousTemplateHasBeenSet() const { return m_usePreviousTemplateHasBeenSet; }
|
||||
inline void SetUsePreviousTemplate(bool value) { m_usePreviousTemplateHasBeenSet = true; m_usePreviousTemplate = value; }
|
||||
inline CreateChangeSetRequest& WithUsePreviousTemplate(bool value) { SetUsePreviousTemplate(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of <code>Parameter</code> structures that specify input parameters for
|
||||
* the change set. For more information, see the <a>Parameter</a> data type.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Parameter>& GetParameters() const{ return m_parameters; }
|
||||
inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
|
||||
inline void SetParameters(const Aws::Vector<Parameter>& value) { m_parametersHasBeenSet = true; m_parameters = value; }
|
||||
inline void SetParameters(Aws::Vector<Parameter>&& value) { m_parametersHasBeenSet = true; m_parameters = std::move(value); }
|
||||
inline CreateChangeSetRequest& WithParameters(const Aws::Vector<Parameter>& value) { SetParameters(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithParameters(Aws::Vector<Parameter>&& value) { SetParameters(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& AddParameters(const Parameter& value) { m_parametersHasBeenSet = true; m_parameters.push_back(value); return *this; }
|
||||
inline CreateChangeSetRequest& AddParameters(Parameter&& value) { m_parametersHasBeenSet = true; m_parameters.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>In some cases, you must explicitly acknowledge that your stack template
|
||||
* contains certain capabilities in order for CloudFormation to create the
|
||||
* stack.</p> <ul> <li> <p> <code>CAPABILITY_IAM</code> and
|
||||
* <code>CAPABILITY_NAMED_IAM</code> </p> <p>Some stack templates might include
|
||||
* resources that can affect permissions in your Amazon Web Services account; for
|
||||
* example, by creating new IAM users. For those stacks, you must explicitly
|
||||
* acknowledge this by specifying one of these capabilities.</p> <p>The following
|
||||
* IAM resources require you to specify either the <code>CAPABILITY_IAM</code> or
|
||||
* <code>CAPABILITY_NAMED_IAM</code> capability.</p> <ul> <li> <p>If you have IAM
|
||||
* resources, you can specify either capability.</p> </li> <li> <p>If you have IAM
|
||||
* resources with custom names, you <i>must</i> specify
|
||||
* <code>CAPABILITY_NAMED_IAM</code>.</p> </li> <li> <p>If you don't specify either
|
||||
* of these capabilities, CloudFormation returns an
|
||||
* <code>InsufficientCapabilities</code> error.</p> </li> </ul> <p>If your stack
|
||||
* template contains these resources, we suggest that you review all permissions
|
||||
* associated with them and edit their permissions if necessary.</p> <ul> <li> <p>
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-accesskey.html">
|
||||
* AWS::IAM::AccessKey</a> </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-group.html">
|
||||
* AWS::IAM::Group</a> </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html">AWS::IAM::InstanceProfile</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html">
|
||||
* AWS::IAM::Policy</a> </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html">
|
||||
* AWS::IAM::Role</a> </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-user.html">
|
||||
* AWS::IAM::User</a> </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-usertogroupaddition.html">AWS::IAM::UserToGroupAddition</a>
|
||||
* </p> </li> </ul> <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities">Acknowledging
|
||||
* IAM resources in CloudFormation templates</a>.</p> </li> <li> <p>
|
||||
* <code>CAPABILITY_AUTO_EXPAND</code> </p> <p>Some template contain macros. Macros
|
||||
* perform custom processing on templates; this can include simple actions like
|
||||
* find-and-replace operations, all the way to extensive transformations of entire
|
||||
* templates. Because of this, users typically create a change set from the
|
||||
* processed template, so that they can review the changes resulting from the
|
||||
* macros before actually creating the stack. If your stack template contains one
|
||||
* or more macros, and you choose to create a stack directly from the processed
|
||||
* template, without first reviewing the resulting changes in a change set, you
|
||||
* must acknowledge this capability. This includes the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html">AWS::Include</a>
|
||||
* and <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html">AWS::Serverless</a>
|
||||
* transforms, which are macros hosted by CloudFormation.</p> <p>This
|
||||
* capacity doesn't apply to creating change sets, and specifying it when creating
|
||||
* change sets has no effect.</p> <p>If you want to create a stack from a stack
|
||||
* template that contains macros <i>and</i> nested stacks, you must create or
|
||||
* update the stack directly from the template using the <a>CreateStack</a> or
|
||||
* <a>UpdateStack</a> action, and specifying this capability.</p> <p>For
|
||||
* more information about macros, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html">Perform
|
||||
* custom processing on CloudFormation templates with template macros</a>.</p>
|
||||
* </li> </ul> <p>Only one of the <code>Capabilities</code> and
|
||||
* <code>ResourceType</code> parameters can be specified.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Capability>& GetCapabilities() const{ return m_capabilities; }
|
||||
inline bool CapabilitiesHasBeenSet() const { return m_capabilitiesHasBeenSet; }
|
||||
inline void SetCapabilities(const Aws::Vector<Capability>& value) { m_capabilitiesHasBeenSet = true; m_capabilities = value; }
|
||||
inline void SetCapabilities(Aws::Vector<Capability>&& value) { m_capabilitiesHasBeenSet = true; m_capabilities = std::move(value); }
|
||||
inline CreateChangeSetRequest& WithCapabilities(const Aws::Vector<Capability>& value) { SetCapabilities(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithCapabilities(Aws::Vector<Capability>&& value) { SetCapabilities(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& AddCapabilities(const Capability& value) { m_capabilitiesHasBeenSet = true; m_capabilities.push_back(value); return *this; }
|
||||
inline CreateChangeSetRequest& AddCapabilities(Capability&& value) { m_capabilitiesHasBeenSet = true; m_capabilities.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The template resource types that you have permissions to work with if you
|
||||
* execute this change set, such as <code>AWS::EC2::Instance</code>,
|
||||
* <code>AWS::EC2::*</code>, or <code>Custom::MyCustomInstance</code>.</p> <p>If
|
||||
* the list of resource types doesn't include a resource type that you're updating,
|
||||
* the stack update fails. By default, CloudFormation grants permissions to all
|
||||
* resource types. IAM uses this parameter for condition keys in IAM policies for
|
||||
* CloudFormation. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html">Control
|
||||
* access with Identity and Access Management</a> in the <i>CloudFormation User
|
||||
* Guide</i>.</p> <p>Only one of the <code>Capabilities</code> and
|
||||
* <code>ResourceType</code> parameters can be specified.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetResourceTypes() const{ return m_resourceTypes; }
|
||||
inline bool ResourceTypesHasBeenSet() const { return m_resourceTypesHasBeenSet; }
|
||||
inline void SetResourceTypes(const Aws::Vector<Aws::String>& value) { m_resourceTypesHasBeenSet = true; m_resourceTypes = value; }
|
||||
inline void SetResourceTypes(Aws::Vector<Aws::String>&& value) { m_resourceTypesHasBeenSet = true; m_resourceTypes = std::move(value); }
|
||||
inline CreateChangeSetRequest& WithResourceTypes(const Aws::Vector<Aws::String>& value) { SetResourceTypes(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithResourceTypes(Aws::Vector<Aws::String>&& value) { SetResourceTypes(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& AddResourceTypes(const Aws::String& value) { m_resourceTypesHasBeenSet = true; m_resourceTypes.push_back(value); return *this; }
|
||||
inline CreateChangeSetRequest& AddResourceTypes(Aws::String&& value) { m_resourceTypesHasBeenSet = true; m_resourceTypes.push_back(std::move(value)); return *this; }
|
||||
inline CreateChangeSetRequest& AddResourceTypes(const char* value) { m_resourceTypesHasBeenSet = true; m_resourceTypes.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of an IAM role that CloudFormation assumes
|
||||
* when executing the change set. CloudFormation uses the role's credentials to
|
||||
* make calls on your behalf. CloudFormation uses this role for all future
|
||||
* operations on the stack. Provided that users have permission to operate on the
|
||||
* stack, CloudFormation uses this role even if the users don't have permission to
|
||||
* pass it. Ensure that the role grants least permission.</p> <p>If you don't
|
||||
* specify a value, CloudFormation uses the role that was previously associated
|
||||
* with the stack. If no role is available, CloudFormation uses a temporary session
|
||||
* that is generated from your user credentials.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRoleARN() const{ return m_roleARN; }
|
||||
inline bool RoleARNHasBeenSet() const { return m_roleARNHasBeenSet; }
|
||||
inline void SetRoleARN(const Aws::String& value) { m_roleARNHasBeenSet = true; m_roleARN = value; }
|
||||
inline void SetRoleARN(Aws::String&& value) { m_roleARNHasBeenSet = true; m_roleARN = std::move(value); }
|
||||
inline void SetRoleARN(const char* value) { m_roleARNHasBeenSet = true; m_roleARN.assign(value); }
|
||||
inline CreateChangeSetRequest& WithRoleARN(const Aws::String& value) { SetRoleARN(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithRoleARN(Aws::String&& value) { SetRoleARN(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& WithRoleARN(const char* value) { SetRoleARN(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The rollback triggers for CloudFormation to monitor during stack creation and
|
||||
* updating operations, and for the specified monitoring period afterwards.</p>
|
||||
*/
|
||||
inline const RollbackConfiguration& GetRollbackConfiguration() const{ return m_rollbackConfiguration; }
|
||||
inline bool RollbackConfigurationHasBeenSet() const { return m_rollbackConfigurationHasBeenSet; }
|
||||
inline void SetRollbackConfiguration(const RollbackConfiguration& value) { m_rollbackConfigurationHasBeenSet = true; m_rollbackConfiguration = value; }
|
||||
inline void SetRollbackConfiguration(RollbackConfiguration&& value) { m_rollbackConfigurationHasBeenSet = true; m_rollbackConfiguration = std::move(value); }
|
||||
inline CreateChangeSetRequest& WithRollbackConfiguration(const RollbackConfiguration& value) { SetRollbackConfiguration(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithRollbackConfiguration(RollbackConfiguration&& value) { SetRollbackConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Names (ARNs) of Amazon SNS topics that CloudFormation
|
||||
* associates with the stack. To remove all associated notification topics, specify
|
||||
* an empty list.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetNotificationARNs() const{ return m_notificationARNs; }
|
||||
inline bool NotificationARNsHasBeenSet() const { return m_notificationARNsHasBeenSet; }
|
||||
inline void SetNotificationARNs(const Aws::Vector<Aws::String>& value) { m_notificationARNsHasBeenSet = true; m_notificationARNs = value; }
|
||||
inline void SetNotificationARNs(Aws::Vector<Aws::String>&& value) { m_notificationARNsHasBeenSet = true; m_notificationARNs = std::move(value); }
|
||||
inline CreateChangeSetRequest& WithNotificationARNs(const Aws::Vector<Aws::String>& value) { SetNotificationARNs(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithNotificationARNs(Aws::Vector<Aws::String>&& value) { SetNotificationARNs(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& AddNotificationARNs(const Aws::String& value) { m_notificationARNsHasBeenSet = true; m_notificationARNs.push_back(value); return *this; }
|
||||
inline CreateChangeSetRequest& AddNotificationARNs(Aws::String&& value) { m_notificationARNsHasBeenSet = true; m_notificationARNs.push_back(std::move(value)); return *this; }
|
||||
inline CreateChangeSetRequest& AddNotificationARNs(const char* value) { m_notificationARNsHasBeenSet = true; m_notificationARNs.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Key-value pairs to associate with this stack. CloudFormation also propagates
|
||||
* these tags to resources in the stack. You can specify a maximum of 50 tags.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateChangeSetRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateChangeSetRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the change set. The name must be unique among all change sets
|
||||
* that are associated with the specified stack.</p> <p>A change set name can
|
||||
* contain only alphanumeric, case sensitive characters, and hyphens. It must start
|
||||
* with an alphabetical character and can't exceed 128 characters.</p>
|
||||
*/
|
||||
inline const Aws::String& GetChangeSetName() const{ return m_changeSetName; }
|
||||
inline bool ChangeSetNameHasBeenSet() const { return m_changeSetNameHasBeenSet; }
|
||||
inline void SetChangeSetName(const Aws::String& value) { m_changeSetNameHasBeenSet = true; m_changeSetName = value; }
|
||||
inline void SetChangeSetName(Aws::String&& value) { m_changeSetNameHasBeenSet = true; m_changeSetName = std::move(value); }
|
||||
inline void SetChangeSetName(const char* value) { m_changeSetNameHasBeenSet = true; m_changeSetName.assign(value); }
|
||||
inline CreateChangeSetRequest& WithChangeSetName(const Aws::String& value) { SetChangeSetName(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithChangeSetName(Aws::String&& value) { SetChangeSetName(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& WithChangeSetName(const char* value) { SetChangeSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for this <code>CreateChangeSet</code> request. Specify
|
||||
* this token if you plan to retry requests so that CloudFormation knows that
|
||||
* you're not attempting to create another change set with the same name. You might
|
||||
* retry <code>CreateChangeSet</code> requests to ensure that CloudFormation
|
||||
* successfully received them.</p>
|
||||
*/
|
||||
inline const Aws::String& GetClientToken() const{ return m_clientToken; }
|
||||
inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }
|
||||
inline void SetClientToken(const Aws::String& value) { m_clientTokenHasBeenSet = true; m_clientToken = value; }
|
||||
inline void SetClientToken(Aws::String&& value) { m_clientTokenHasBeenSet = true; m_clientToken = std::move(value); }
|
||||
inline void SetClientToken(const char* value) { m_clientTokenHasBeenSet = true; m_clientToken.assign(value); }
|
||||
inline CreateChangeSetRequest& WithClientToken(const Aws::String& value) { SetClientToken(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithClientToken(Aws::String&& value) { SetClientToken(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& WithClientToken(const char* value) { SetClientToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A description to help you identify this change set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
|
||||
inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
|
||||
inline CreateChangeSetRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type of change set operation. To create a change set for a new stack,
|
||||
* specify <code>CREATE</code>. To create a change set for an existing stack,
|
||||
* specify <code>UPDATE</code>. To create a change set for an import operation,
|
||||
* specify <code>IMPORT</code>.</p> <p>If you create a change set for a new stack,
|
||||
* CloudFormation creates a stack with a unique stack ID, but no template or
|
||||
* resources. The stack will be in the <code>REVIEW_IN_PROGRESS</code> state until
|
||||
* you execute the change set.</p> <p>By default, CloudFormation specifies
|
||||
* <code>UPDATE</code>. You can't use the <code>UPDATE</code> type to create a
|
||||
* change set for a new stack or the <code>CREATE</code> type to create a change
|
||||
* set for an existing stack.</p>
|
||||
*/
|
||||
inline const ChangeSetType& GetChangeSetType() const{ return m_changeSetType; }
|
||||
inline bool ChangeSetTypeHasBeenSet() const { return m_changeSetTypeHasBeenSet; }
|
||||
inline void SetChangeSetType(const ChangeSetType& value) { m_changeSetTypeHasBeenSet = true; m_changeSetType = value; }
|
||||
inline void SetChangeSetType(ChangeSetType&& value) { m_changeSetTypeHasBeenSet = true; m_changeSetType = std::move(value); }
|
||||
inline CreateChangeSetRequest& WithChangeSetType(const ChangeSetType& value) { SetChangeSetType(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithChangeSetType(ChangeSetType&& value) { SetChangeSetType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The resources to import into your stack.</p>
|
||||
*/
|
||||
inline const Aws::Vector<ResourceToImport>& GetResourcesToImport() const{ return m_resourcesToImport; }
|
||||
inline bool ResourcesToImportHasBeenSet() const { return m_resourcesToImportHasBeenSet; }
|
||||
inline void SetResourcesToImport(const Aws::Vector<ResourceToImport>& value) { m_resourcesToImportHasBeenSet = true; m_resourcesToImport = value; }
|
||||
inline void SetResourcesToImport(Aws::Vector<ResourceToImport>&& value) { m_resourcesToImportHasBeenSet = true; m_resourcesToImport = std::move(value); }
|
||||
inline CreateChangeSetRequest& WithResourcesToImport(const Aws::Vector<ResourceToImport>& value) { SetResourcesToImport(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithResourcesToImport(Aws::Vector<ResourceToImport>&& value) { SetResourcesToImport(std::move(value)); return *this;}
|
||||
inline CreateChangeSetRequest& AddResourcesToImport(const ResourceToImport& value) { m_resourcesToImportHasBeenSet = true; m_resourcesToImport.push_back(value); return *this; }
|
||||
inline CreateChangeSetRequest& AddResourcesToImport(ResourceToImport&& value) { m_resourcesToImportHasBeenSet = true; m_resourcesToImport.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Creates a change set for the all nested stacks specified in the template. The
|
||||
* default behavior of this action is set to <code>False</code>. To include nested
|
||||
* sets in a change set, specify <code>True</code>.</p>
|
||||
*/
|
||||
inline bool GetIncludeNestedStacks() const{ return m_includeNestedStacks; }
|
||||
inline bool IncludeNestedStacksHasBeenSet() const { return m_includeNestedStacksHasBeenSet; }
|
||||
inline void SetIncludeNestedStacks(bool value) { m_includeNestedStacksHasBeenSet = true; m_includeNestedStacks = value; }
|
||||
inline CreateChangeSetRequest& WithIncludeNestedStacks(bool value) { SetIncludeNestedStacks(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Determines what action will be taken if stack creation fails. If this
|
||||
* parameter is specified, the <code>DisableRollback</code> parameter to the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html">ExecuteChangeSet</a>
|
||||
* API operation must not be specified. This must be one of these values:</p> <ul>
|
||||
* <li> <p> <code>DELETE</code> - Deletes the change set if the stack creation
|
||||
* fails. This is only valid when the <code>ChangeSetType</code> parameter is set
|
||||
* to <code>CREATE</code>. If the deletion of the stack fails, the status of the
|
||||
* stack is <code>DELETE_FAILED</code>.</p> </li> <li> <p> <code>DO_NOTHING</code>
|
||||
* - if the stack creation fails, do nothing. This is equivalent to specifying
|
||||
* <code>true</code> for the <code>DisableRollback</code> parameter to the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html">ExecuteChangeSet</a>
|
||||
* API operation.</p> </li> <li> <p> <code>ROLLBACK</code> - if the stack creation
|
||||
* fails, roll back the stack. This is equivalent to specifying <code>false</code>
|
||||
* for the <code>DisableRollback</code> parameter to the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html">ExecuteChangeSet</a>
|
||||
* API operation.</p> </li> </ul> <p>For nested stacks, when the
|
||||
* <code>OnStackFailure</code> parameter is set to <code>DELETE</code> for the
|
||||
* change set for the parent stack, any failure in a child stack will cause the
|
||||
* parent stack creation to fail and all stacks to be deleted.</p>
|
||||
*/
|
||||
inline const OnStackFailure& GetOnStackFailure() const{ return m_onStackFailure; }
|
||||
inline bool OnStackFailureHasBeenSet() const { return m_onStackFailureHasBeenSet; }
|
||||
inline void SetOnStackFailure(const OnStackFailure& value) { m_onStackFailureHasBeenSet = true; m_onStackFailure = value; }
|
||||
inline void SetOnStackFailure(OnStackFailure&& value) { m_onStackFailureHasBeenSet = true; m_onStackFailure = std::move(value); }
|
||||
inline CreateChangeSetRequest& WithOnStackFailure(const OnStackFailure& value) { SetOnStackFailure(value); return *this;}
|
||||
inline CreateChangeSetRequest& WithOnStackFailure(OnStackFailure&& value) { SetOnStackFailure(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates if the change set imports resources that already exist.</p>
|
||||
* <p>This parameter can only import resources that have custom names in templates.
|
||||
* For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html">name
|
||||
* type</a> in the <i>CloudFormation User Guide</i>. To import resources that do
|
||||
* not accept custom names, such as EC2 instances, use the resource import feature
|
||||
* instead. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import.html">Import
|
||||
* Amazon Web Services resources into a CloudFormation stack with a resource
|
||||
* import</a> in the <i>CloudFormation User Guide</i>.</p>
|
||||
*/
|
||||
inline bool GetImportExistingResources() const{ return m_importExistingResources; }
|
||||
inline bool ImportExistingResourcesHasBeenSet() const { return m_importExistingResourcesHasBeenSet; }
|
||||
inline void SetImportExistingResources(bool value) { m_importExistingResourcesHasBeenSet = true; m_importExistingResources = value; }
|
||||
inline CreateChangeSetRequest& WithImportExistingResources(bool value) { SetImportExistingResources(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_templateBody;
|
||||
bool m_templateBodyHasBeenSet = false;
|
||||
|
||||
Aws::String m_templateURL;
|
||||
bool m_templateURLHasBeenSet = false;
|
||||
|
||||
bool m_usePreviousTemplate;
|
||||
bool m_usePreviousTemplateHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Parameter> m_parameters;
|
||||
bool m_parametersHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Capability> m_capabilities;
|
||||
bool m_capabilitiesHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_resourceTypes;
|
||||
bool m_resourceTypesHasBeenSet = false;
|
||||
|
||||
Aws::String m_roleARN;
|
||||
bool m_roleARNHasBeenSet = false;
|
||||
|
||||
RollbackConfiguration m_rollbackConfiguration;
|
||||
bool m_rollbackConfigurationHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_notificationARNs;
|
||||
bool m_notificationARNsHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
|
||||
Aws::String m_changeSetName;
|
||||
bool m_changeSetNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_clientToken;
|
||||
bool m_clientTokenHasBeenSet = false;
|
||||
|
||||
Aws::String m_description;
|
||||
bool m_descriptionHasBeenSet = false;
|
||||
|
||||
ChangeSetType m_changeSetType;
|
||||
bool m_changeSetTypeHasBeenSet = false;
|
||||
|
||||
Aws::Vector<ResourceToImport> m_resourcesToImport;
|
||||
bool m_resourcesToImportHasBeenSet = false;
|
||||
|
||||
bool m_includeNestedStacks;
|
||||
bool m_includeNestedStacksHasBeenSet = false;
|
||||
|
||||
OnStackFailure m_onStackFailure;
|
||||
bool m_onStackFailureHasBeenSet = false;
|
||||
|
||||
bool m_importExistingResources;
|
||||
bool m_importExistingResourcesHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,87 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The output for the <a>CreateChangeSet</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/CreateChangeSetOutput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class CreateChangeSetResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CreateChangeSetResult();
|
||||
AWS_CLOUDFORMATION_API CreateChangeSetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API CreateChangeSetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the change set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetId() const{ return m_id; }
|
||||
inline void SetId(const Aws::String& value) { m_id = value; }
|
||||
inline void SetId(Aws::String&& value) { m_id = std::move(value); }
|
||||
inline void SetId(const char* value) { m_id.assign(value); }
|
||||
inline CreateChangeSetResult& WithId(const Aws::String& value) { SetId(value); return *this;}
|
||||
inline CreateChangeSetResult& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
|
||||
inline CreateChangeSetResult& WithId(const char* value) { SetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique ID of the stack.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackId() const{ return m_stackId; }
|
||||
inline void SetStackId(const Aws::String& value) { m_stackId = value; }
|
||||
inline void SetStackId(Aws::String&& value) { m_stackId = std::move(value); }
|
||||
inline void SetStackId(const char* value) { m_stackId.assign(value); }
|
||||
inline CreateChangeSetResult& WithStackId(const Aws::String& value) { SetStackId(value); return *this;}
|
||||
inline CreateChangeSetResult& WithStackId(Aws::String&& value) { SetStackId(std::move(value)); return *this;}
|
||||
inline CreateChangeSetResult& WithStackId(const char* value) { SetStackId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline CreateChangeSetResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline CreateChangeSetResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_id;
|
||||
|
||||
Aws::String m_stackId;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,117 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/TemplateConfiguration.h>
|
||||
#include <aws/cloudformation/model/ResourceDefinition.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateGeneratedTemplateRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CreateGeneratedTemplateRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "CreateGeneratedTemplate"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An optional list of resources to be included in the generated template.</p>
|
||||
* <p> If no resources are specified,the template will be created without any
|
||||
* resources. Resources can be added to the template using the
|
||||
* <code>UpdateGeneratedTemplate</code> API action.</p>
|
||||
*/
|
||||
inline const Aws::Vector<ResourceDefinition>& GetResources() const{ return m_resources; }
|
||||
inline bool ResourcesHasBeenSet() const { return m_resourcesHasBeenSet; }
|
||||
inline void SetResources(const Aws::Vector<ResourceDefinition>& value) { m_resourcesHasBeenSet = true; m_resources = value; }
|
||||
inline void SetResources(Aws::Vector<ResourceDefinition>&& value) { m_resourcesHasBeenSet = true; m_resources = std::move(value); }
|
||||
inline CreateGeneratedTemplateRequest& WithResources(const Aws::Vector<ResourceDefinition>& value) { SetResources(value); return *this;}
|
||||
inline CreateGeneratedTemplateRequest& WithResources(Aws::Vector<ResourceDefinition>&& value) { SetResources(std::move(value)); return *this;}
|
||||
inline CreateGeneratedTemplateRequest& AddResources(const ResourceDefinition& value) { m_resourcesHasBeenSet = true; m_resources.push_back(value); return *this; }
|
||||
inline CreateGeneratedTemplateRequest& AddResources(ResourceDefinition&& value) { m_resourcesHasBeenSet = true; m_resources.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name assigned to the generated template.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGeneratedTemplateName() const{ return m_generatedTemplateName; }
|
||||
inline bool GeneratedTemplateNameHasBeenSet() const { return m_generatedTemplateNameHasBeenSet; }
|
||||
inline void SetGeneratedTemplateName(const Aws::String& value) { m_generatedTemplateNameHasBeenSet = true; m_generatedTemplateName = value; }
|
||||
inline void SetGeneratedTemplateName(Aws::String&& value) { m_generatedTemplateNameHasBeenSet = true; m_generatedTemplateName = std::move(value); }
|
||||
inline void SetGeneratedTemplateName(const char* value) { m_generatedTemplateNameHasBeenSet = true; m_generatedTemplateName.assign(value); }
|
||||
inline CreateGeneratedTemplateRequest& WithGeneratedTemplateName(const Aws::String& value) { SetGeneratedTemplateName(value); return *this;}
|
||||
inline CreateGeneratedTemplateRequest& WithGeneratedTemplateName(Aws::String&& value) { SetGeneratedTemplateName(std::move(value)); return *this;}
|
||||
inline CreateGeneratedTemplateRequest& WithGeneratedTemplateName(const char* value) { SetGeneratedTemplateName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An optional name or ARN of a stack to use as the base stack for the generated
|
||||
* template.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline CreateGeneratedTemplateRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline CreateGeneratedTemplateRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline CreateGeneratedTemplateRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The configuration details of the generated template, including the
|
||||
* <code>DeletionPolicy</code> and <code>UpdateReplacePolicy</code>.</p>
|
||||
*/
|
||||
inline const TemplateConfiguration& GetTemplateConfiguration() const{ return m_templateConfiguration; }
|
||||
inline bool TemplateConfigurationHasBeenSet() const { return m_templateConfigurationHasBeenSet; }
|
||||
inline void SetTemplateConfiguration(const TemplateConfiguration& value) { m_templateConfigurationHasBeenSet = true; m_templateConfiguration = value; }
|
||||
inline void SetTemplateConfiguration(TemplateConfiguration&& value) { m_templateConfigurationHasBeenSet = true; m_templateConfiguration = std::move(value); }
|
||||
inline CreateGeneratedTemplateRequest& WithTemplateConfiguration(const TemplateConfiguration& value) { SetTemplateConfiguration(value); return *this;}
|
||||
inline CreateGeneratedTemplateRequest& WithTemplateConfiguration(TemplateConfiguration&& value) { SetTemplateConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<ResourceDefinition> m_resources;
|
||||
bool m_resourcesHasBeenSet = false;
|
||||
|
||||
Aws::String m_generatedTemplateName;
|
||||
bool m_generatedTemplateNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
TemplateConfiguration m_templateConfiguration;
|
||||
bool m_templateConfigurationHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateGeneratedTemplateResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CreateGeneratedTemplateResult();
|
||||
AWS_CLOUDFORMATION_API CreateGeneratedTemplateResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API CreateGeneratedTemplateResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the generated template.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGeneratedTemplateId() const{ return m_generatedTemplateId; }
|
||||
inline void SetGeneratedTemplateId(const Aws::String& value) { m_generatedTemplateId = value; }
|
||||
inline void SetGeneratedTemplateId(Aws::String&& value) { m_generatedTemplateId = std::move(value); }
|
||||
inline void SetGeneratedTemplateId(const char* value) { m_generatedTemplateId.assign(value); }
|
||||
inline CreateGeneratedTemplateResult& WithGeneratedTemplateId(const Aws::String& value) { SetGeneratedTemplateId(value); return *this;}
|
||||
inline CreateGeneratedTemplateResult& WithGeneratedTemplateId(Aws::String&& value) { SetGeneratedTemplateId(std::move(value)); return *this;}
|
||||
inline CreateGeneratedTemplateResult& WithGeneratedTemplateId(const char* value) { SetGeneratedTemplateId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline CreateGeneratedTemplateResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline CreateGeneratedTemplateResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_generatedTemplateId;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,225 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/DeploymentTargets.h>
|
||||
#include <aws/cloudformation/model/StackSetOperationPreferences.h>
|
||||
#include <aws/cloudformation/model/CallAs.h>
|
||||
#include <aws/cloudformation/model/Parameter.h>
|
||||
#include <utility>
|
||||
#include <aws/core/utils/UUID.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateStackInstancesRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CreateStackInstancesRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "CreateStackInstances"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or unique ID of the stack set that you want to create stack
|
||||
* instances from.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackSetName() const{ return m_stackSetName; }
|
||||
inline bool StackSetNameHasBeenSet() const { return m_stackSetNameHasBeenSet; }
|
||||
inline void SetStackSetName(const Aws::String& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = value; }
|
||||
inline void SetStackSetName(Aws::String&& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = std::move(value); }
|
||||
inline void SetStackSetName(const char* value) { m_stackSetNameHasBeenSet = true; m_stackSetName.assign(value); }
|
||||
inline CreateStackInstancesRequest& WithStackSetName(const Aws::String& value) { SetStackSetName(value); return *this;}
|
||||
inline CreateStackInstancesRequest& WithStackSetName(Aws::String&& value) { SetStackSetName(std::move(value)); return *this;}
|
||||
inline CreateStackInstancesRequest& WithStackSetName(const char* value) { SetStackSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Self-managed permissions] The names of one or more Amazon Web Services
|
||||
* accounts that you want to create stack instances in the specified Region(s)
|
||||
* for.</p> <p>You can specify <code>Accounts</code> or
|
||||
* <code>DeploymentTargets</code>, but not both.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetAccounts() const{ return m_accounts; }
|
||||
inline bool AccountsHasBeenSet() const { return m_accountsHasBeenSet; }
|
||||
inline void SetAccounts(const Aws::Vector<Aws::String>& value) { m_accountsHasBeenSet = true; m_accounts = value; }
|
||||
inline void SetAccounts(Aws::Vector<Aws::String>&& value) { m_accountsHasBeenSet = true; m_accounts = std::move(value); }
|
||||
inline CreateStackInstancesRequest& WithAccounts(const Aws::Vector<Aws::String>& value) { SetAccounts(value); return *this;}
|
||||
inline CreateStackInstancesRequest& WithAccounts(Aws::Vector<Aws::String>&& value) { SetAccounts(std::move(value)); return *this;}
|
||||
inline CreateStackInstancesRequest& AddAccounts(const Aws::String& value) { m_accountsHasBeenSet = true; m_accounts.push_back(value); return *this; }
|
||||
inline CreateStackInstancesRequest& AddAccounts(Aws::String&& value) { m_accountsHasBeenSet = true; m_accounts.push_back(std::move(value)); return *this; }
|
||||
inline CreateStackInstancesRequest& AddAccounts(const char* value) { m_accountsHasBeenSet = true; m_accounts.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Service-managed permissions] The Organizations accounts for which to create
|
||||
* stack instances in the specified Amazon Web Services Regions.</p> <p>You can
|
||||
* specify <code>Accounts</code> or <code>DeploymentTargets</code>, but not
|
||||
* both.</p>
|
||||
*/
|
||||
inline const DeploymentTargets& GetDeploymentTargets() const{ return m_deploymentTargets; }
|
||||
inline bool DeploymentTargetsHasBeenSet() const { return m_deploymentTargetsHasBeenSet; }
|
||||
inline void SetDeploymentTargets(const DeploymentTargets& value) { m_deploymentTargetsHasBeenSet = true; m_deploymentTargets = value; }
|
||||
inline void SetDeploymentTargets(DeploymentTargets&& value) { m_deploymentTargetsHasBeenSet = true; m_deploymentTargets = std::move(value); }
|
||||
inline CreateStackInstancesRequest& WithDeploymentTargets(const DeploymentTargets& value) { SetDeploymentTargets(value); return *this;}
|
||||
inline CreateStackInstancesRequest& WithDeploymentTargets(DeploymentTargets&& value) { SetDeploymentTargets(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The names of one or more Amazon Web Services Regions where you want to create
|
||||
* stack instances using the specified Amazon Web Services accounts.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetRegions() const{ return m_regions; }
|
||||
inline bool RegionsHasBeenSet() const { return m_regionsHasBeenSet; }
|
||||
inline void SetRegions(const Aws::Vector<Aws::String>& value) { m_regionsHasBeenSet = true; m_regions = value; }
|
||||
inline void SetRegions(Aws::Vector<Aws::String>&& value) { m_regionsHasBeenSet = true; m_regions = std::move(value); }
|
||||
inline CreateStackInstancesRequest& WithRegions(const Aws::Vector<Aws::String>& value) { SetRegions(value); return *this;}
|
||||
inline CreateStackInstancesRequest& WithRegions(Aws::Vector<Aws::String>&& value) { SetRegions(std::move(value)); return *this;}
|
||||
inline CreateStackInstancesRequest& AddRegions(const Aws::String& value) { m_regionsHasBeenSet = true; m_regions.push_back(value); return *this; }
|
||||
inline CreateStackInstancesRequest& AddRegions(Aws::String&& value) { m_regionsHasBeenSet = true; m_regions.push_back(std::move(value)); return *this; }
|
||||
inline CreateStackInstancesRequest& AddRegions(const char* value) { m_regionsHasBeenSet = true; m_regions.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of stack set parameters whose values you want to override in the
|
||||
* selected stack instances.</p> <p>Any overridden parameter values will be applied
|
||||
* to all stack instances in the specified accounts and Amazon Web Services
|
||||
* Regions. When specifying parameters and their values, be aware of how
|
||||
* CloudFormation sets parameter values during stack instance operations:</p> <ul>
|
||||
* <li> <p>To override the current value for a parameter, include the parameter and
|
||||
* specify its value.</p> </li> <li> <p>To leave an overridden parameter set to its
|
||||
* present value, include the parameter and specify <code>UsePreviousValue</code>
|
||||
* as <code>true</code>. (You can't specify both a value and set
|
||||
* <code>UsePreviousValue</code> to <code>true</code>.)</p> </li> <li> <p>To set an
|
||||
* overridden parameter back to the value specified in the stack set, specify a
|
||||
* parameter list but don't include the parameter in the list.</p> </li> <li> <p>To
|
||||
* leave all parameters set to their present values, don't specify this property at
|
||||
* all.</p> </li> </ul> <p>During stack set updates, any parameter values
|
||||
* overridden for a stack instance aren't updated, but retain their overridden
|
||||
* value.</p> <p>You can only override the parameter <i>values</i> that are
|
||||
* specified in the stack set; to add or delete a parameter itself, use <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html">UpdateStackSet</a>
|
||||
* to update the stack set template.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Parameter>& GetParameterOverrides() const{ return m_parameterOverrides; }
|
||||
inline bool ParameterOverridesHasBeenSet() const { return m_parameterOverridesHasBeenSet; }
|
||||
inline void SetParameterOverrides(const Aws::Vector<Parameter>& value) { m_parameterOverridesHasBeenSet = true; m_parameterOverrides = value; }
|
||||
inline void SetParameterOverrides(Aws::Vector<Parameter>&& value) { m_parameterOverridesHasBeenSet = true; m_parameterOverrides = std::move(value); }
|
||||
inline CreateStackInstancesRequest& WithParameterOverrides(const Aws::Vector<Parameter>& value) { SetParameterOverrides(value); return *this;}
|
||||
inline CreateStackInstancesRequest& WithParameterOverrides(Aws::Vector<Parameter>&& value) { SetParameterOverrides(std::move(value)); return *this;}
|
||||
inline CreateStackInstancesRequest& AddParameterOverrides(const Parameter& value) { m_parameterOverridesHasBeenSet = true; m_parameterOverrides.push_back(value); return *this; }
|
||||
inline CreateStackInstancesRequest& AddParameterOverrides(Parameter&& value) { m_parameterOverridesHasBeenSet = true; m_parameterOverrides.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Preferences for how CloudFormation performs this stack set operation.</p>
|
||||
*/
|
||||
inline const StackSetOperationPreferences& GetOperationPreferences() const{ return m_operationPreferences; }
|
||||
inline bool OperationPreferencesHasBeenSet() const { return m_operationPreferencesHasBeenSet; }
|
||||
inline void SetOperationPreferences(const StackSetOperationPreferences& value) { m_operationPreferencesHasBeenSet = true; m_operationPreferences = value; }
|
||||
inline void SetOperationPreferences(StackSetOperationPreferences&& value) { m_operationPreferencesHasBeenSet = true; m_operationPreferences = std::move(value); }
|
||||
inline CreateStackInstancesRequest& WithOperationPreferences(const StackSetOperationPreferences& value) { SetOperationPreferences(value); return *this;}
|
||||
inline CreateStackInstancesRequest& WithOperationPreferences(StackSetOperationPreferences&& value) { SetOperationPreferences(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique identifier for this stack set operation.</p> <p>The operation ID
|
||||
* also functions as an idempotency token, to ensure that CloudFormation performs
|
||||
* the stack set operation only once, even if you retry the request multiple times.
|
||||
* You might retry stack set operation requests to ensure that CloudFormation
|
||||
* successfully received them.</p> <p>If you don't specify an operation ID, the SDK
|
||||
* generates one automatically.</p> <p>Repeating this stack set operation with a
|
||||
* new operation ID retries all stack instances whose status is
|
||||
* <code>OUTDATED</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetOperationId() const{ return m_operationId; }
|
||||
inline bool OperationIdHasBeenSet() const { return m_operationIdHasBeenSet; }
|
||||
inline void SetOperationId(const Aws::String& value) { m_operationIdHasBeenSet = true; m_operationId = value; }
|
||||
inline void SetOperationId(Aws::String&& value) { m_operationIdHasBeenSet = true; m_operationId = std::move(value); }
|
||||
inline void SetOperationId(const char* value) { m_operationIdHasBeenSet = true; m_operationId.assign(value); }
|
||||
inline CreateStackInstancesRequest& WithOperationId(const Aws::String& value) { SetOperationId(value); return *this;}
|
||||
inline CreateStackInstancesRequest& WithOperationId(Aws::String&& value) { SetOperationId(std::move(value)); return *this;}
|
||||
inline CreateStackInstancesRequest& WithOperationId(const char* value) { SetOperationId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Service-managed permissions] Specifies whether you are acting as an account
|
||||
* administrator in the organization's management account or as a delegated
|
||||
* administrator in a member account.</p> <p>By default, <code>SELF</code> is
|
||||
* specified. Use <code>SELF</code> for stack sets with self-managed
|
||||
* permissions.</p> <ul> <li> <p>If you are signed in to the management account,
|
||||
* specify <code>SELF</code>.</p> </li> <li> <p>If you are signed in to a delegated
|
||||
* administrator account, specify <code>DELEGATED_ADMIN</code>.</p> <p>Your Amazon
|
||||
* Web Services account must be registered as a delegated administrator in the
|
||||
* management account. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html">Register
|
||||
* a delegated administrator</a> in the <i>CloudFormation User Guide</i>.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const CallAs& GetCallAs() const{ return m_callAs; }
|
||||
inline bool CallAsHasBeenSet() const { return m_callAsHasBeenSet; }
|
||||
inline void SetCallAs(const CallAs& value) { m_callAsHasBeenSet = true; m_callAs = value; }
|
||||
inline void SetCallAs(CallAs&& value) { m_callAsHasBeenSet = true; m_callAs = std::move(value); }
|
||||
inline CreateStackInstancesRequest& WithCallAs(const CallAs& value) { SetCallAs(value); return *this;}
|
||||
inline CreateStackInstancesRequest& WithCallAs(CallAs&& value) { SetCallAs(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackSetName;
|
||||
bool m_stackSetNameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_accounts;
|
||||
bool m_accountsHasBeenSet = false;
|
||||
|
||||
DeploymentTargets m_deploymentTargets;
|
||||
bool m_deploymentTargetsHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_regions;
|
||||
bool m_regionsHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Parameter> m_parameterOverrides;
|
||||
bool m_parameterOverridesHasBeenSet = false;
|
||||
|
||||
StackSetOperationPreferences m_operationPreferences;
|
||||
bool m_operationPreferencesHasBeenSet = false;
|
||||
|
||||
Aws::String m_operationId;
|
||||
bool m_operationIdHasBeenSet = false;
|
||||
|
||||
CallAs m_callAs;
|
||||
bool m_callAsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateStackInstancesResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CreateStackInstancesResult();
|
||||
AWS_CLOUDFORMATION_API CreateStackInstancesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API CreateStackInstancesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique identifier for this stack set operation.</p>
|
||||
*/
|
||||
inline const Aws::String& GetOperationId() const{ return m_operationId; }
|
||||
inline void SetOperationId(const Aws::String& value) { m_operationId = value; }
|
||||
inline void SetOperationId(Aws::String&& value) { m_operationId = std::move(value); }
|
||||
inline void SetOperationId(const char* value) { m_operationId.assign(value); }
|
||||
inline CreateStackInstancesResult& WithOperationId(const Aws::String& value) { SetOperationId(value); return *this;}
|
||||
inline CreateStackInstancesResult& WithOperationId(Aws::String&& value) { SetOperationId(std::move(value)); return *this;}
|
||||
inline CreateStackInstancesResult& WithOperationId(const char* value) { SetOperationId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline CreateStackInstancesResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline CreateStackInstancesResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_operationId;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,483 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/RollbackConfiguration.h>
|
||||
#include <aws/cloudformation/model/OnFailure.h>
|
||||
#include <aws/cloudformation/model/Parameter.h>
|
||||
#include <aws/cloudformation/model/Capability.h>
|
||||
#include <aws/cloudformation/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for <a>CreateStack</a> action.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/CreateStackInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class CreateStackRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CreateStackRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "CreateStack"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name that's associated with the stack. The name must be unique in the
|
||||
* Region in which you are creating the stack.</p> <p>A stack name can
|
||||
* contain only alphanumeric characters (case sensitive) and hyphens. It must start
|
||||
* with an alphabetical character and can't be longer than 128 characters.</p>
|
||||
*
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline CreateStackRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline CreateStackRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Structure containing the template body with a minimum length of 1 byte and a
|
||||
* maximum length of 51,200 bytes.</p> <p>Conditional: You must specify either the
|
||||
* <code>TemplateBody</code> or the <code>TemplateURL</code> parameter, but not
|
||||
* both.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTemplateBody() const{ return m_templateBody; }
|
||||
inline bool TemplateBodyHasBeenSet() const { return m_templateBodyHasBeenSet; }
|
||||
inline void SetTemplateBody(const Aws::String& value) { m_templateBodyHasBeenSet = true; m_templateBody = value; }
|
||||
inline void SetTemplateBody(Aws::String&& value) { m_templateBodyHasBeenSet = true; m_templateBody = std::move(value); }
|
||||
inline void SetTemplateBody(const char* value) { m_templateBodyHasBeenSet = true; m_templateBody.assign(value); }
|
||||
inline CreateStackRequest& WithTemplateBody(const Aws::String& value) { SetTemplateBody(value); return *this;}
|
||||
inline CreateStackRequest& WithTemplateBody(Aws::String&& value) { SetTemplateBody(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& WithTemplateBody(const char* value) { SetTemplateBody(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Location of file containing the template body. The URL must point to a
|
||||
* template (max size: 460,800 bytes) that's located in an Amazon S3 bucket or a
|
||||
* Systems Manager document. The location for an Amazon S3 bucket must start with
|
||||
* <code>https://</code>.</p> <p>Conditional: You must specify either the
|
||||
* <code>TemplateBody</code> or the <code>TemplateURL</code> parameter, but not
|
||||
* both.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTemplateURL() const{ return m_templateURL; }
|
||||
inline bool TemplateURLHasBeenSet() const { return m_templateURLHasBeenSet; }
|
||||
inline void SetTemplateURL(const Aws::String& value) { m_templateURLHasBeenSet = true; m_templateURL = value; }
|
||||
inline void SetTemplateURL(Aws::String&& value) { m_templateURLHasBeenSet = true; m_templateURL = std::move(value); }
|
||||
inline void SetTemplateURL(const char* value) { m_templateURLHasBeenSet = true; m_templateURL.assign(value); }
|
||||
inline CreateStackRequest& WithTemplateURL(const Aws::String& value) { SetTemplateURL(value); return *this;}
|
||||
inline CreateStackRequest& WithTemplateURL(Aws::String&& value) { SetTemplateURL(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& WithTemplateURL(const char* value) { SetTemplateURL(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of <code>Parameter</code> structures that specify input parameters for
|
||||
* the stack. For more information, see the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html">Parameter</a>
|
||||
* data type.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Parameter>& GetParameters() const{ return m_parameters; }
|
||||
inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
|
||||
inline void SetParameters(const Aws::Vector<Parameter>& value) { m_parametersHasBeenSet = true; m_parameters = value; }
|
||||
inline void SetParameters(Aws::Vector<Parameter>&& value) { m_parametersHasBeenSet = true; m_parameters = std::move(value); }
|
||||
inline CreateStackRequest& WithParameters(const Aws::Vector<Parameter>& value) { SetParameters(value); return *this;}
|
||||
inline CreateStackRequest& WithParameters(Aws::Vector<Parameter>&& value) { SetParameters(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& AddParameters(const Parameter& value) { m_parametersHasBeenSet = true; m_parameters.push_back(value); return *this; }
|
||||
inline CreateStackRequest& AddParameters(Parameter&& value) { m_parametersHasBeenSet = true; m_parameters.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Set to <code>true</code> to disable rollback of the stack if stack creation
|
||||
* failed. You can specify either <code>DisableRollback</code> or
|
||||
* <code>OnFailure</code>, but not both.</p> <p>Default: <code>false</code> </p>
|
||||
*/
|
||||
inline bool GetDisableRollback() const{ return m_disableRollback; }
|
||||
inline bool DisableRollbackHasBeenSet() const { return m_disableRollbackHasBeenSet; }
|
||||
inline void SetDisableRollback(bool value) { m_disableRollbackHasBeenSet = true; m_disableRollback = value; }
|
||||
inline CreateStackRequest& WithDisableRollback(bool value) { SetDisableRollback(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The rollback triggers for CloudFormation to monitor during stack creation and
|
||||
* updating operations, and for the specified monitoring period afterwards.</p>
|
||||
*/
|
||||
inline const RollbackConfiguration& GetRollbackConfiguration() const{ return m_rollbackConfiguration; }
|
||||
inline bool RollbackConfigurationHasBeenSet() const { return m_rollbackConfigurationHasBeenSet; }
|
||||
inline void SetRollbackConfiguration(const RollbackConfiguration& value) { m_rollbackConfigurationHasBeenSet = true; m_rollbackConfiguration = value; }
|
||||
inline void SetRollbackConfiguration(RollbackConfiguration&& value) { m_rollbackConfigurationHasBeenSet = true; m_rollbackConfiguration = std::move(value); }
|
||||
inline CreateStackRequest& WithRollbackConfiguration(const RollbackConfiguration& value) { SetRollbackConfiguration(value); return *this;}
|
||||
inline CreateStackRequest& WithRollbackConfiguration(RollbackConfiguration&& value) { SetRollbackConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The amount of time that can pass before the stack status becomes
|
||||
* <code>CREATE_FAILED</code>; if <code>DisableRollback</code> is not set or is set
|
||||
* to <code>false</code>, the stack will be rolled back.</p>
|
||||
*/
|
||||
inline int GetTimeoutInMinutes() const{ return m_timeoutInMinutes; }
|
||||
inline bool TimeoutInMinutesHasBeenSet() const { return m_timeoutInMinutesHasBeenSet; }
|
||||
inline void SetTimeoutInMinutes(int value) { m_timeoutInMinutesHasBeenSet = true; m_timeoutInMinutes = value; }
|
||||
inline CreateStackRequest& WithTimeoutInMinutes(int value) { SetTimeoutInMinutes(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon SNS topic ARNs to publish stack related events. You can find your
|
||||
* Amazon SNS topic ARNs using the Amazon SNS console or your Command Line
|
||||
* Interface (CLI).</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetNotificationARNs() const{ return m_notificationARNs; }
|
||||
inline bool NotificationARNsHasBeenSet() const { return m_notificationARNsHasBeenSet; }
|
||||
inline void SetNotificationARNs(const Aws::Vector<Aws::String>& value) { m_notificationARNsHasBeenSet = true; m_notificationARNs = value; }
|
||||
inline void SetNotificationARNs(Aws::Vector<Aws::String>&& value) { m_notificationARNsHasBeenSet = true; m_notificationARNs = std::move(value); }
|
||||
inline CreateStackRequest& WithNotificationARNs(const Aws::Vector<Aws::String>& value) { SetNotificationARNs(value); return *this;}
|
||||
inline CreateStackRequest& WithNotificationARNs(Aws::Vector<Aws::String>&& value) { SetNotificationARNs(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& AddNotificationARNs(const Aws::String& value) { m_notificationARNsHasBeenSet = true; m_notificationARNs.push_back(value); return *this; }
|
||||
inline CreateStackRequest& AddNotificationARNs(Aws::String&& value) { m_notificationARNsHasBeenSet = true; m_notificationARNs.push_back(std::move(value)); return *this; }
|
||||
inline CreateStackRequest& AddNotificationARNs(const char* value) { m_notificationARNsHasBeenSet = true; m_notificationARNs.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>In some cases, you must explicitly acknowledge that your stack template
|
||||
* contains certain capabilities in order for CloudFormation to create the
|
||||
* stack.</p> <ul> <li> <p> <code>CAPABILITY_IAM</code> and
|
||||
* <code>CAPABILITY_NAMED_IAM</code> </p> <p>Some stack templates might include
|
||||
* resources that can affect permissions in your Amazon Web Services account; for
|
||||
* example, by creating new IAM users. For those stacks, you must explicitly
|
||||
* acknowledge this by specifying one of these capabilities.</p> <p>The following
|
||||
* IAM resources require you to specify either the <code>CAPABILITY_IAM</code> or
|
||||
* <code>CAPABILITY_NAMED_IAM</code> capability.</p> <ul> <li> <p>If you have IAM
|
||||
* resources, you can specify either capability.</p> </li> <li> <p>If you have IAM
|
||||
* resources with custom names, you <i>must</i> specify
|
||||
* <code>CAPABILITY_NAMED_IAM</code>.</p> </li> <li> <p>If you don't specify either
|
||||
* of these capabilities, CloudFormation returns an
|
||||
* <code>InsufficientCapabilities</code> error.</p> </li> </ul> <p>If your stack
|
||||
* template contains these resources, we recommend that you review all permissions
|
||||
* associated with them and edit their permissions if necessary.</p> <ul> <li> <p>
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-accesskey.html">AWS::IAM::AccessKey</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-group.html">AWS::IAM::Group</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html">AWS::IAM::InstanceProfile</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html">AWS::IAM::Policy</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html">AWS::IAM::Role</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-user.html">AWS::IAM::User</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-usertogroupaddition.html">AWS::IAM::UserToGroupAddition</a>
|
||||
* </p> </li> </ul> <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities">Acknowledging
|
||||
* IAM resources in CloudFormation templates</a>.</p> </li> <li> <p>
|
||||
* <code>CAPABILITY_AUTO_EXPAND</code> </p> <p>Some template contain macros. Macros
|
||||
* perform custom processing on templates; this can include simple actions like
|
||||
* find-and-replace operations, all the way to extensive transformations of entire
|
||||
* templates. Because of this, users typically create a change set from the
|
||||
* processed template, so that they can review the changes resulting from the
|
||||
* macros before actually creating the stack. If your stack template contains one
|
||||
* or more macros, and you choose to create a stack directly from the processed
|
||||
* template, without first reviewing the resulting changes in a change set, you
|
||||
* must acknowledge this capability. This includes the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html">AWS::Include</a>
|
||||
* and <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html">AWS::Serverless</a>
|
||||
* transforms, which are macros hosted by CloudFormation.</p> <p>If you want to
|
||||
* create a stack from a stack template that contains macros <i>and</i> nested
|
||||
* stacks, you must create the stack directly from the template using this
|
||||
* capability.</p> <p>You should only create stacks directly from a
|
||||
* stack template that contains macros if you know what processing the macro
|
||||
* performs.</p> <p>Each macro relies on an underlying Lambda service function for
|
||||
* processing stack templates. Be aware that the Lambda function owner can update
|
||||
* the function operation without CloudFormation being notified.</p>
|
||||
* <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html">Perform
|
||||
* custom processing on CloudFormation templates with template macros</a>.</p>
|
||||
* </li> </ul> <p>Only one of the <code>Capabilities</code> and
|
||||
* <code>ResourceType</code> parameters can be specified.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Capability>& GetCapabilities() const{ return m_capabilities; }
|
||||
inline bool CapabilitiesHasBeenSet() const { return m_capabilitiesHasBeenSet; }
|
||||
inline void SetCapabilities(const Aws::Vector<Capability>& value) { m_capabilitiesHasBeenSet = true; m_capabilities = value; }
|
||||
inline void SetCapabilities(Aws::Vector<Capability>&& value) { m_capabilitiesHasBeenSet = true; m_capabilities = std::move(value); }
|
||||
inline CreateStackRequest& WithCapabilities(const Aws::Vector<Capability>& value) { SetCapabilities(value); return *this;}
|
||||
inline CreateStackRequest& WithCapabilities(Aws::Vector<Capability>&& value) { SetCapabilities(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& AddCapabilities(const Capability& value) { m_capabilitiesHasBeenSet = true; m_capabilities.push_back(value); return *this; }
|
||||
inline CreateStackRequest& AddCapabilities(Capability&& value) { m_capabilitiesHasBeenSet = true; m_capabilities.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The template resource types that you have permissions to work with for this
|
||||
* create stack action, such as <code>AWS::EC2::Instance</code>,
|
||||
* <code>AWS::EC2::*</code>, or <code>Custom::MyCustomInstance</code>. Use the
|
||||
* following syntax to describe template resource types: <code>AWS::*</code> (for
|
||||
* all Amazon Web Services resources), <code>Custom::*</code> (for all custom
|
||||
* resources), <code>Custom::<i>logical_ID</i> </code> (for a specific custom
|
||||
* resource), <code>AWS::<i>service_name</i>::*</code> (for all resources of a
|
||||
* particular Amazon Web Services service), and
|
||||
* <code>AWS::<i>service_name</i>::<i>resource_logical_ID</i> </code> (for a
|
||||
* specific Amazon Web Services resource).</p> <p>If the list of resource types
|
||||
* doesn't include a resource that you're creating, the stack creation fails. By
|
||||
* default, CloudFormation grants permissions to all resource types. IAM uses this
|
||||
* parameter for CloudFormation-specific condition keys in IAM policies. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html">Control
|
||||
* access with Identity and Access Management</a>.</p> <p>Only one of the
|
||||
* <code>Capabilities</code> and <code>ResourceType</code> parameters can be
|
||||
* specified.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetResourceTypes() const{ return m_resourceTypes; }
|
||||
inline bool ResourceTypesHasBeenSet() const { return m_resourceTypesHasBeenSet; }
|
||||
inline void SetResourceTypes(const Aws::Vector<Aws::String>& value) { m_resourceTypesHasBeenSet = true; m_resourceTypes = value; }
|
||||
inline void SetResourceTypes(Aws::Vector<Aws::String>&& value) { m_resourceTypesHasBeenSet = true; m_resourceTypes = std::move(value); }
|
||||
inline CreateStackRequest& WithResourceTypes(const Aws::Vector<Aws::String>& value) { SetResourceTypes(value); return *this;}
|
||||
inline CreateStackRequest& WithResourceTypes(Aws::Vector<Aws::String>&& value) { SetResourceTypes(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& AddResourceTypes(const Aws::String& value) { m_resourceTypesHasBeenSet = true; m_resourceTypes.push_back(value); return *this; }
|
||||
inline CreateStackRequest& AddResourceTypes(Aws::String&& value) { m_resourceTypesHasBeenSet = true; m_resourceTypes.push_back(std::move(value)); return *this; }
|
||||
inline CreateStackRequest& AddResourceTypes(const char* value) { m_resourceTypesHasBeenSet = true; m_resourceTypes.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of an IAM role that CloudFormation assumes to
|
||||
* create the stack. CloudFormation uses the role's credentials to make calls on
|
||||
* your behalf. CloudFormation always uses this role for all future operations on
|
||||
* the stack. Provided that users have permission to operate on the stack,
|
||||
* CloudFormation uses this role even if the users don't have permission to pass
|
||||
* it. Ensure that the role grants least privilege.</p> <p>If you don't specify a
|
||||
* value, CloudFormation uses the role that was previously associated with the
|
||||
* stack. If no role is available, CloudFormation uses a temporary session that's
|
||||
* generated from your user credentials.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRoleARN() const{ return m_roleARN; }
|
||||
inline bool RoleARNHasBeenSet() const { return m_roleARNHasBeenSet; }
|
||||
inline void SetRoleARN(const Aws::String& value) { m_roleARNHasBeenSet = true; m_roleARN = value; }
|
||||
inline void SetRoleARN(Aws::String&& value) { m_roleARNHasBeenSet = true; m_roleARN = std::move(value); }
|
||||
inline void SetRoleARN(const char* value) { m_roleARNHasBeenSet = true; m_roleARN.assign(value); }
|
||||
inline CreateStackRequest& WithRoleARN(const Aws::String& value) { SetRoleARN(value); return *this;}
|
||||
inline CreateStackRequest& WithRoleARN(Aws::String&& value) { SetRoleARN(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& WithRoleARN(const char* value) { SetRoleARN(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Determines what action will be taken if stack creation fails. This must be
|
||||
* one of: <code>DO_NOTHING</code>, <code>ROLLBACK</code>, or <code>DELETE</code>.
|
||||
* You can specify either <code>OnFailure</code> or <code>DisableRollback</code>,
|
||||
* but not both.</p> <p>Default: <code>ROLLBACK</code> </p>
|
||||
*/
|
||||
inline const OnFailure& GetOnFailure() const{ return m_onFailure; }
|
||||
inline bool OnFailureHasBeenSet() const { return m_onFailureHasBeenSet; }
|
||||
inline void SetOnFailure(const OnFailure& value) { m_onFailureHasBeenSet = true; m_onFailure = value; }
|
||||
inline void SetOnFailure(OnFailure&& value) { m_onFailureHasBeenSet = true; m_onFailure = std::move(value); }
|
||||
inline CreateStackRequest& WithOnFailure(const OnFailure& value) { SetOnFailure(value); return *this;}
|
||||
inline CreateStackRequest& WithOnFailure(OnFailure&& value) { SetOnFailure(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Structure containing the stack policy body. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/protect-stack-resources.html">Prevent
|
||||
* updates to stack resources</a> in the <i>CloudFormation User Guide</i>. You can
|
||||
* specify either the <code>StackPolicyBody</code> or the
|
||||
* <code>StackPolicyURL</code> parameter, but not both.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackPolicyBody() const{ return m_stackPolicyBody; }
|
||||
inline bool StackPolicyBodyHasBeenSet() const { return m_stackPolicyBodyHasBeenSet; }
|
||||
inline void SetStackPolicyBody(const Aws::String& value) { m_stackPolicyBodyHasBeenSet = true; m_stackPolicyBody = value; }
|
||||
inline void SetStackPolicyBody(Aws::String&& value) { m_stackPolicyBodyHasBeenSet = true; m_stackPolicyBody = std::move(value); }
|
||||
inline void SetStackPolicyBody(const char* value) { m_stackPolicyBodyHasBeenSet = true; m_stackPolicyBody.assign(value); }
|
||||
inline CreateStackRequest& WithStackPolicyBody(const Aws::String& value) { SetStackPolicyBody(value); return *this;}
|
||||
inline CreateStackRequest& WithStackPolicyBody(Aws::String&& value) { SetStackPolicyBody(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& WithStackPolicyBody(const char* value) { SetStackPolicyBody(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Location of a file containing the stack policy. The URL must point to a
|
||||
* policy (maximum size: 16 KB) located in an S3 bucket in the same Region as the
|
||||
* stack. The location for an Amazon S3 bucket must start with
|
||||
* <code>https://</code>. You can specify either the <code>StackPolicyBody</code>
|
||||
* or the <code>StackPolicyURL</code> parameter, but not both.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackPolicyURL() const{ return m_stackPolicyURL; }
|
||||
inline bool StackPolicyURLHasBeenSet() const { return m_stackPolicyURLHasBeenSet; }
|
||||
inline void SetStackPolicyURL(const Aws::String& value) { m_stackPolicyURLHasBeenSet = true; m_stackPolicyURL = value; }
|
||||
inline void SetStackPolicyURL(Aws::String&& value) { m_stackPolicyURLHasBeenSet = true; m_stackPolicyURL = std::move(value); }
|
||||
inline void SetStackPolicyURL(const char* value) { m_stackPolicyURLHasBeenSet = true; m_stackPolicyURL.assign(value); }
|
||||
inline CreateStackRequest& WithStackPolicyURL(const Aws::String& value) { SetStackPolicyURL(value); return *this;}
|
||||
inline CreateStackRequest& WithStackPolicyURL(Aws::String&& value) { SetStackPolicyURL(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& WithStackPolicyURL(const char* value) { SetStackPolicyURL(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Key-value pairs to associate with this stack. CloudFormation also propagates
|
||||
* these tags to the resources created in the stack. A maximum number of 50 tags
|
||||
* can be specified.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateStackRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateStackRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateStackRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for this <code>CreateStack</code> request. Specify this
|
||||
* token if you plan to retry requests so that CloudFormation knows that you're not
|
||||
* attempting to create a stack with the same name. You might retry
|
||||
* <code>CreateStack</code> requests to ensure that CloudFormation successfully
|
||||
* received them.</p> <p>All events initiated by a given stack operation are
|
||||
* assigned the same client request token, which you can use to track operations.
|
||||
* For example, if you execute a <code>CreateStack</code> operation with the token
|
||||
* <code>token1</code>, then all the <code>StackEvents</code> generated by that
|
||||
* operation will have <code>ClientRequestToken</code> set as
|
||||
* <code>token1</code>.</p> <p>In the console, stack operations display the client
|
||||
* request token on the Events tab. Stack operations that are initiated from the
|
||||
* console use the token format <i>Console-StackOperation-ID</i>, which helps you
|
||||
* easily identify the stack operation . For example, if you create a stack using
|
||||
* the console, each stack event would be assigned the same token in the following
|
||||
* format:
|
||||
* <code>Console-CreateStack-7f59c3cf-00d2-40c7-b2ff-e75db0987002</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetClientRequestToken() const{ return m_clientRequestToken; }
|
||||
inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
|
||||
inline void SetClientRequestToken(const Aws::String& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = value; }
|
||||
inline void SetClientRequestToken(Aws::String&& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = std::move(value); }
|
||||
inline void SetClientRequestToken(const char* value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken.assign(value); }
|
||||
inline CreateStackRequest& WithClientRequestToken(const Aws::String& value) { SetClientRequestToken(value); return *this;}
|
||||
inline CreateStackRequest& WithClientRequestToken(Aws::String&& value) { SetClientRequestToken(std::move(value)); return *this;}
|
||||
inline CreateStackRequest& WithClientRequestToken(const char* value) { SetClientRequestToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Whether to enable termination protection on 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 <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html">Protect
|
||||
* CloudFormation stacks from being deleted</a> in the <i>CloudFormation User
|
||||
* Guide</i>. Termination protection is deactivated on stacks by default.</p>
|
||||
* <p>For <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html">nested
|
||||
* stacks</a>, termination protection is set on the root stack and can't be changed
|
||||
* directly on the nested stack.</p>
|
||||
*/
|
||||
inline bool GetEnableTerminationProtection() const{ return m_enableTerminationProtection; }
|
||||
inline bool EnableTerminationProtectionHasBeenSet() const { return m_enableTerminationProtectionHasBeenSet; }
|
||||
inline void SetEnableTerminationProtection(bool value) { m_enableTerminationProtectionHasBeenSet = true; m_enableTerminationProtection = value; }
|
||||
inline CreateStackRequest& WithEnableTerminationProtection(bool value) { SetEnableTerminationProtection(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>When set to <code>true</code>, newly created resources are deleted when the
|
||||
* operation rolls back. This includes newly created resources marked with a
|
||||
* deletion policy of <code>Retain</code>.</p> <p>Default: <code>false</code> </p>
|
||||
*/
|
||||
inline bool GetRetainExceptOnCreate() const{ return m_retainExceptOnCreate; }
|
||||
inline bool RetainExceptOnCreateHasBeenSet() const { return m_retainExceptOnCreateHasBeenSet; }
|
||||
inline void SetRetainExceptOnCreate(bool value) { m_retainExceptOnCreateHasBeenSet = true; m_retainExceptOnCreate = value; }
|
||||
inline CreateStackRequest& WithRetainExceptOnCreate(bool value) { SetRetainExceptOnCreate(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_templateBody;
|
||||
bool m_templateBodyHasBeenSet = false;
|
||||
|
||||
Aws::String m_templateURL;
|
||||
bool m_templateURLHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Parameter> m_parameters;
|
||||
bool m_parametersHasBeenSet = false;
|
||||
|
||||
bool m_disableRollback;
|
||||
bool m_disableRollbackHasBeenSet = false;
|
||||
|
||||
RollbackConfiguration m_rollbackConfiguration;
|
||||
bool m_rollbackConfigurationHasBeenSet = false;
|
||||
|
||||
int m_timeoutInMinutes;
|
||||
bool m_timeoutInMinutesHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_notificationARNs;
|
||||
bool m_notificationARNsHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Capability> m_capabilities;
|
||||
bool m_capabilitiesHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_resourceTypes;
|
||||
bool m_resourceTypesHasBeenSet = false;
|
||||
|
||||
Aws::String m_roleARN;
|
||||
bool m_roleARNHasBeenSet = false;
|
||||
|
||||
OnFailure m_onFailure;
|
||||
bool m_onFailureHasBeenSet = false;
|
||||
|
||||
Aws::String m_stackPolicyBody;
|
||||
bool m_stackPolicyBodyHasBeenSet = false;
|
||||
|
||||
Aws::String m_stackPolicyURL;
|
||||
bool m_stackPolicyURLHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
|
||||
Aws::String m_clientRequestToken;
|
||||
bool m_clientRequestTokenHasBeenSet = false;
|
||||
|
||||
bool m_enableTerminationProtection;
|
||||
bool m_enableTerminationProtectionHasBeenSet = false;
|
||||
|
||||
bool m_retainExceptOnCreate;
|
||||
bool m_retainExceptOnCreateHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,71 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The output for a <a>CreateStack</a> action.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/CreateStackOutput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class CreateStackResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CreateStackResult();
|
||||
AWS_CLOUDFORMATION_API CreateStackResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API CreateStackResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Unique identifier of the stack.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackId() const{ return m_stackId; }
|
||||
inline void SetStackId(const Aws::String& value) { m_stackId = value; }
|
||||
inline void SetStackId(Aws::String&& value) { m_stackId = std::move(value); }
|
||||
inline void SetStackId(const char* value) { m_stackId.assign(value); }
|
||||
inline CreateStackResult& WithStackId(const Aws::String& value) { SetStackId(value); return *this;}
|
||||
inline CreateStackResult& WithStackId(Aws::String&& value) { SetStackId(std::move(value)); return *this;}
|
||||
inline CreateStackResult& WithStackId(const char* value) { SetStackId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline CreateStackResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline CreateStackResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackId;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,408 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/PermissionModels.h>
|
||||
#include <aws/cloudformation/model/AutoDeployment.h>
|
||||
#include <aws/cloudformation/model/CallAs.h>
|
||||
#include <aws/cloudformation/model/ManagedExecution.h>
|
||||
#include <aws/cloudformation/model/Parameter.h>
|
||||
#include <aws/cloudformation/model/Capability.h>
|
||||
#include <aws/cloudformation/model/Tag.h>
|
||||
#include <utility>
|
||||
#include <aws/core/utils/UUID.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateStackSetRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CreateStackSetRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "CreateStackSet"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name to associate with the stack set. The name must be unique in the
|
||||
* Region where you create your stack set.</p> <p>A stack name can contain
|
||||
* only alphanumeric characters (case-sensitive) and hyphens. It must start with an
|
||||
* alphabetic character and can't be longer than 128 characters.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackSetName() const{ return m_stackSetName; }
|
||||
inline bool StackSetNameHasBeenSet() const { return m_stackSetNameHasBeenSet; }
|
||||
inline void SetStackSetName(const Aws::String& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = value; }
|
||||
inline void SetStackSetName(Aws::String&& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = std::move(value); }
|
||||
inline void SetStackSetName(const char* value) { m_stackSetNameHasBeenSet = true; m_stackSetName.assign(value); }
|
||||
inline CreateStackSetRequest& WithStackSetName(const Aws::String& value) { SetStackSetName(value); return *this;}
|
||||
inline CreateStackSetRequest& WithStackSetName(Aws::String&& value) { SetStackSetName(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& WithStackSetName(const char* value) { SetStackSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A description of the stack set. You can use the description to identify the
|
||||
* stack set's purpose or other important information.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
|
||||
inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
|
||||
inline CreateStackSetRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline CreateStackSetRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The structure that contains the template body, with a minimum length of 1
|
||||
* byte and a maximum length of 51,200 bytes.</p> <p>Conditional: You must specify
|
||||
* either the TemplateBody or the TemplateURL parameter, but not both.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTemplateBody() const{ return m_templateBody; }
|
||||
inline bool TemplateBodyHasBeenSet() const { return m_templateBodyHasBeenSet; }
|
||||
inline void SetTemplateBody(const Aws::String& value) { m_templateBodyHasBeenSet = true; m_templateBody = value; }
|
||||
inline void SetTemplateBody(Aws::String&& value) { m_templateBodyHasBeenSet = true; m_templateBody = std::move(value); }
|
||||
inline void SetTemplateBody(const char* value) { m_templateBodyHasBeenSet = true; m_templateBody.assign(value); }
|
||||
inline CreateStackSetRequest& WithTemplateBody(const Aws::String& value) { SetTemplateBody(value); return *this;}
|
||||
inline CreateStackSetRequest& WithTemplateBody(Aws::String&& value) { SetTemplateBody(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& WithTemplateBody(const char* value) { SetTemplateBody(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The location of the file that contains the template body. The URL must point
|
||||
* to a template (maximum size: 460,800 bytes) that's located in an Amazon S3
|
||||
* bucket or a Systems Manager document.</p> <p>Conditional: You must specify
|
||||
* either the TemplateBody or the TemplateURL parameter, but not both.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTemplateURL() const{ return m_templateURL; }
|
||||
inline bool TemplateURLHasBeenSet() const { return m_templateURLHasBeenSet; }
|
||||
inline void SetTemplateURL(const Aws::String& value) { m_templateURLHasBeenSet = true; m_templateURL = value; }
|
||||
inline void SetTemplateURL(Aws::String&& value) { m_templateURLHasBeenSet = true; m_templateURL = std::move(value); }
|
||||
inline void SetTemplateURL(const char* value) { m_templateURLHasBeenSet = true; m_templateURL.assign(value); }
|
||||
inline CreateStackSetRequest& WithTemplateURL(const Aws::String& value) { SetTemplateURL(value); return *this;}
|
||||
inline CreateStackSetRequest& WithTemplateURL(Aws::String&& value) { SetTemplateURL(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& WithTemplateURL(const char* value) { SetTemplateURL(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The stack ID you are importing into a new stack set. Specify the Amazon
|
||||
* Resource Name (ARN) of the stack.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackId() const{ return m_stackId; }
|
||||
inline bool StackIdHasBeenSet() const { return m_stackIdHasBeenSet; }
|
||||
inline void SetStackId(const Aws::String& value) { m_stackIdHasBeenSet = true; m_stackId = value; }
|
||||
inline void SetStackId(Aws::String&& value) { m_stackIdHasBeenSet = true; m_stackId = std::move(value); }
|
||||
inline void SetStackId(const char* value) { m_stackIdHasBeenSet = true; m_stackId.assign(value); }
|
||||
inline CreateStackSetRequest& WithStackId(const Aws::String& value) { SetStackId(value); return *this;}
|
||||
inline CreateStackSetRequest& WithStackId(Aws::String&& value) { SetStackId(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& WithStackId(const char* value) { SetStackId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The input parameters for the stack set template.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Parameter>& GetParameters() const{ return m_parameters; }
|
||||
inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
|
||||
inline void SetParameters(const Aws::Vector<Parameter>& value) { m_parametersHasBeenSet = true; m_parameters = value; }
|
||||
inline void SetParameters(Aws::Vector<Parameter>&& value) { m_parametersHasBeenSet = true; m_parameters = std::move(value); }
|
||||
inline CreateStackSetRequest& WithParameters(const Aws::Vector<Parameter>& value) { SetParameters(value); return *this;}
|
||||
inline CreateStackSetRequest& WithParameters(Aws::Vector<Parameter>&& value) { SetParameters(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& AddParameters(const Parameter& value) { m_parametersHasBeenSet = true; m_parameters.push_back(value); return *this; }
|
||||
inline CreateStackSetRequest& AddParameters(Parameter&& value) { m_parametersHasBeenSet = true; m_parameters.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>In some cases, you must explicitly acknowledge that your stack set template
|
||||
* contains certain capabilities in order for CloudFormation to create the stack
|
||||
* set and related stack instances.</p> <ul> <li> <p> <code>CAPABILITY_IAM</code>
|
||||
* and <code>CAPABILITY_NAMED_IAM</code> </p> <p>Some stack templates might include
|
||||
* resources that can affect permissions in your Amazon Web Services account; for
|
||||
* example, by creating new IAM users. For those stack sets, you must explicitly
|
||||
* acknowledge this by specifying one of these capabilities.</p> <p>The following
|
||||
* IAM resources require you to specify either the <code>CAPABILITY_IAM</code> or
|
||||
* <code>CAPABILITY_NAMED_IAM</code> capability.</p> <ul> <li> <p>If you have IAM
|
||||
* resources, you can specify either capability.</p> </li> <li> <p>If you have IAM
|
||||
* resources with custom names, you <i>must</i> specify
|
||||
* <code>CAPABILITY_NAMED_IAM</code>.</p> </li> <li> <p>If you don't specify either
|
||||
* of these capabilities, CloudFormation returns an
|
||||
* <code>InsufficientCapabilities</code> error.</p> </li> </ul> <p>If your stack
|
||||
* template contains these resources, we recommend that you review all permissions
|
||||
* associated with them and edit their permissions if necessary.</p> <ul> <li> <p>
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-accesskey.html">AWS::IAM::AccessKey</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-group.html">AWS::IAM::Group</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html">AWS::IAM::InstanceProfile</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html">AWS::IAM::Policy</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html">AWS::IAM::Role</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-user.html">AWS::IAM::User</a>
|
||||
* </p> </li> <li> <p> <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-usertogroupaddition.html">AWS::IAM::UserToGroupAddition</a>
|
||||
* </p> </li> </ul> <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities">Acknowledging
|
||||
* IAM resources in CloudFormation templates</a>.</p> </li> <li> <p>
|
||||
* <code>CAPABILITY_AUTO_EXPAND</code> </p> <p>Some templates reference macros. If
|
||||
* your stack set template references one or more macros, you must create the stack
|
||||
* set directly from the processed template, without first reviewing the resulting
|
||||
* changes in a change set. To create the stack set directly, you must acknowledge
|
||||
* this capability. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html">Using
|
||||
* CloudFormation Macros to Perform Custom Processing on Templates</a>.</p>
|
||||
* <p>Stack sets with service-managed permissions don't currently
|
||||
* support the use of macros in templates. (This includes the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html">AWS::Include</a>
|
||||
* and <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html">AWS::Serverless</a>
|
||||
* transforms, which are macros hosted by CloudFormation.) Even if you specify this
|
||||
* capability for a stack set with service-managed permissions, if you reference a
|
||||
* macro in your template the stack set operation will fail.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const Aws::Vector<Capability>& GetCapabilities() const{ return m_capabilities; }
|
||||
inline bool CapabilitiesHasBeenSet() const { return m_capabilitiesHasBeenSet; }
|
||||
inline void SetCapabilities(const Aws::Vector<Capability>& value) { m_capabilitiesHasBeenSet = true; m_capabilities = value; }
|
||||
inline void SetCapabilities(Aws::Vector<Capability>&& value) { m_capabilitiesHasBeenSet = true; m_capabilities = std::move(value); }
|
||||
inline CreateStackSetRequest& WithCapabilities(const Aws::Vector<Capability>& value) { SetCapabilities(value); return *this;}
|
||||
inline CreateStackSetRequest& WithCapabilities(Aws::Vector<Capability>&& value) { SetCapabilities(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& AddCapabilities(const Capability& value) { m_capabilitiesHasBeenSet = true; m_capabilities.push_back(value); return *this; }
|
||||
inline CreateStackSetRequest& AddCapabilities(Capability&& value) { m_capabilitiesHasBeenSet = true; m_capabilities.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The key-value pairs to associate with this stack set and the stacks created
|
||||
* from it. CloudFormation also propagates these tags to supported resources that
|
||||
* are created in the stacks. A maximum number of 50 tags can be specified.</p>
|
||||
* <p>If you specify tags as part of a <code>CreateStackSet</code> action,
|
||||
* CloudFormation checks to see if you have the required IAM permission to tag
|
||||
* resources. If you don't, the entire <code>CreateStackSet</code> action fails
|
||||
* with an <code>access denied</code> error, and the stack set is not created.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateStackSetRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateStackSetRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateStackSetRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the IAM role to use to create this stack
|
||||
* set.</p> <p>Specify an IAM role only if you are using customized administrator
|
||||
* roles to control which users or groups can manage specific stack sets within the
|
||||
* same administrator account. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs.html">Prerequisites:
|
||||
* Granting Permissions for Stack Set Operations</a> in the <i>CloudFormation User
|
||||
* Guide</i>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAdministrationRoleARN() const{ return m_administrationRoleARN; }
|
||||
inline bool AdministrationRoleARNHasBeenSet() const { return m_administrationRoleARNHasBeenSet; }
|
||||
inline void SetAdministrationRoleARN(const Aws::String& value) { m_administrationRoleARNHasBeenSet = true; m_administrationRoleARN = value; }
|
||||
inline void SetAdministrationRoleARN(Aws::String&& value) { m_administrationRoleARNHasBeenSet = true; m_administrationRoleARN = std::move(value); }
|
||||
inline void SetAdministrationRoleARN(const char* value) { m_administrationRoleARNHasBeenSet = true; m_administrationRoleARN.assign(value); }
|
||||
inline CreateStackSetRequest& WithAdministrationRoleARN(const Aws::String& value) { SetAdministrationRoleARN(value); return *this;}
|
||||
inline CreateStackSetRequest& WithAdministrationRoleARN(Aws::String&& value) { SetAdministrationRoleARN(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& WithAdministrationRoleARN(const char* value) { SetAdministrationRoleARN(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the IAM execution role to use to create the stack set. If you do
|
||||
* not specify an execution role, CloudFormation uses the
|
||||
* <code>AWSCloudFormationStackSetExecutionRole</code> role for the stack set
|
||||
* operation.</p> <p>Specify an IAM role only if you are using customized execution
|
||||
* roles to control which stack resources users and groups can include in their
|
||||
* stack sets.</p>
|
||||
*/
|
||||
inline const Aws::String& GetExecutionRoleName() const{ return m_executionRoleName; }
|
||||
inline bool ExecutionRoleNameHasBeenSet() const { return m_executionRoleNameHasBeenSet; }
|
||||
inline void SetExecutionRoleName(const Aws::String& value) { m_executionRoleNameHasBeenSet = true; m_executionRoleName = value; }
|
||||
inline void SetExecutionRoleName(Aws::String&& value) { m_executionRoleNameHasBeenSet = true; m_executionRoleName = std::move(value); }
|
||||
inline void SetExecutionRoleName(const char* value) { m_executionRoleNameHasBeenSet = true; m_executionRoleName.assign(value); }
|
||||
inline CreateStackSetRequest& WithExecutionRoleName(const Aws::String& value) { SetExecutionRoleName(value); return *this;}
|
||||
inline CreateStackSetRequest& WithExecutionRoleName(Aws::String&& value) { SetExecutionRoleName(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& WithExecutionRoleName(const char* value) { SetExecutionRoleName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Describes how the IAM roles required for stack set operations are created. By
|
||||
* default, <code>SELF-MANAGED</code> is specified.</p> <ul> <li> <p>With
|
||||
* <code>self-managed</code> permissions, you must create the administrator and
|
||||
* execution roles required to deploy to target accounts. For more information, see
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html">Grant
|
||||
* Self-Managed Stack Set Permissions</a>.</p> </li> <li> <p>With
|
||||
* <code>service-managed</code> permissions, StackSets automatically creates the
|
||||
* IAM roles required to deploy to accounts managed by Organizations. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-service-managed.html">Grant
|
||||
* Service-Managed Stack Set Permissions</a>.</p> </li> </ul>
|
||||
*/
|
||||
inline const PermissionModels& GetPermissionModel() const{ return m_permissionModel; }
|
||||
inline bool PermissionModelHasBeenSet() const { return m_permissionModelHasBeenSet; }
|
||||
inline void SetPermissionModel(const PermissionModels& value) { m_permissionModelHasBeenSet = true; m_permissionModel = value; }
|
||||
inline void SetPermissionModel(PermissionModels&& value) { m_permissionModelHasBeenSet = true; m_permissionModel = std::move(value); }
|
||||
inline CreateStackSetRequest& WithPermissionModel(const PermissionModels& value) { SetPermissionModel(value); return *this;}
|
||||
inline CreateStackSetRequest& WithPermissionModel(PermissionModels&& value) { SetPermissionModel(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Describes whether StackSets automatically deploys to Organizations accounts
|
||||
* that are added to the target organization or organizational unit (OU). Specify
|
||||
* only if <code>PermissionModel</code> is <code>SERVICE_MANAGED</code>.</p>
|
||||
*/
|
||||
inline const AutoDeployment& GetAutoDeployment() const{ return m_autoDeployment; }
|
||||
inline bool AutoDeploymentHasBeenSet() const { return m_autoDeploymentHasBeenSet; }
|
||||
inline void SetAutoDeployment(const AutoDeployment& value) { m_autoDeploymentHasBeenSet = true; m_autoDeployment = value; }
|
||||
inline void SetAutoDeployment(AutoDeployment&& value) { m_autoDeploymentHasBeenSet = true; m_autoDeployment = std::move(value); }
|
||||
inline CreateStackSetRequest& WithAutoDeployment(const AutoDeployment& value) { SetAutoDeployment(value); return *this;}
|
||||
inline CreateStackSetRequest& WithAutoDeployment(AutoDeployment&& value) { SetAutoDeployment(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Service-managed permissions] Specifies whether you are acting as an account
|
||||
* administrator in the organization's management account or as a delegated
|
||||
* administrator in a member account.</p> <p>By default, <code>SELF</code> is
|
||||
* specified. Use <code>SELF</code> for stack sets with self-managed
|
||||
* permissions.</p> <ul> <li> <p>To create a stack set with service-managed
|
||||
* permissions while signed in to the management account, specify
|
||||
* <code>SELF</code>.</p> </li> <li> <p>To create a stack set with service-managed
|
||||
* permissions while signed in to a delegated administrator account, specify
|
||||
* <code>DELEGATED_ADMIN</code>.</p> <p>Your Amazon Web Services account must be
|
||||
* registered as a delegated admin in the management account. For more information,
|
||||
* see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html">Register
|
||||
* a delegated administrator</a> in the <i>CloudFormation User Guide</i>.</p> </li>
|
||||
* </ul> <p>Stack sets with service-managed permissions are created in the
|
||||
* management account, including stack sets that are created by delegated
|
||||
* administrators.</p>
|
||||
*/
|
||||
inline const CallAs& GetCallAs() const{ return m_callAs; }
|
||||
inline bool CallAsHasBeenSet() const { return m_callAsHasBeenSet; }
|
||||
inline void SetCallAs(const CallAs& value) { m_callAsHasBeenSet = true; m_callAs = value; }
|
||||
inline void SetCallAs(CallAs&& value) { m_callAsHasBeenSet = true; m_callAs = std::move(value); }
|
||||
inline CreateStackSetRequest& WithCallAs(const CallAs& value) { SetCallAs(value); return *this;}
|
||||
inline CreateStackSetRequest& WithCallAs(CallAs&& value) { SetCallAs(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for this <code>CreateStackSet</code> request. Specify
|
||||
* this token if you plan to retry requests so that CloudFormation knows that
|
||||
* you're not attempting to create another stack set with the same name. You might
|
||||
* retry <code>CreateStackSet</code> requests to ensure that CloudFormation
|
||||
* successfully received them.</p> <p>If you don't specify an operation ID, the SDK
|
||||
* generates one automatically.</p>
|
||||
*/
|
||||
inline const Aws::String& GetClientRequestToken() const{ return m_clientRequestToken; }
|
||||
inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
|
||||
inline void SetClientRequestToken(const Aws::String& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = value; }
|
||||
inline void SetClientRequestToken(Aws::String&& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = std::move(value); }
|
||||
inline void SetClientRequestToken(const char* value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken.assign(value); }
|
||||
inline CreateStackSetRequest& WithClientRequestToken(const Aws::String& value) { SetClientRequestToken(value); return *this;}
|
||||
inline CreateStackSetRequest& WithClientRequestToken(Aws::String&& value) { SetClientRequestToken(std::move(value)); return *this;}
|
||||
inline CreateStackSetRequest& WithClientRequestToken(const char* value) { SetClientRequestToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Describes whether StackSets performs non-conflicting operations concurrently
|
||||
* and queues conflicting operations.</p>
|
||||
*/
|
||||
inline const ManagedExecution& GetManagedExecution() const{ return m_managedExecution; }
|
||||
inline bool ManagedExecutionHasBeenSet() const { return m_managedExecutionHasBeenSet; }
|
||||
inline void SetManagedExecution(const ManagedExecution& value) { m_managedExecutionHasBeenSet = true; m_managedExecution = value; }
|
||||
inline void SetManagedExecution(ManagedExecution&& value) { m_managedExecutionHasBeenSet = true; m_managedExecution = std::move(value); }
|
||||
inline CreateStackSetRequest& WithManagedExecution(const ManagedExecution& value) { SetManagedExecution(value); return *this;}
|
||||
inline CreateStackSetRequest& WithManagedExecution(ManagedExecution&& value) { SetManagedExecution(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackSetName;
|
||||
bool m_stackSetNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_description;
|
||||
bool m_descriptionHasBeenSet = false;
|
||||
|
||||
Aws::String m_templateBody;
|
||||
bool m_templateBodyHasBeenSet = false;
|
||||
|
||||
Aws::String m_templateURL;
|
||||
bool m_templateURLHasBeenSet = false;
|
||||
|
||||
Aws::String m_stackId;
|
||||
bool m_stackIdHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Parameter> m_parameters;
|
||||
bool m_parametersHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Capability> m_capabilities;
|
||||
bool m_capabilitiesHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
|
||||
Aws::String m_administrationRoleARN;
|
||||
bool m_administrationRoleARNHasBeenSet = false;
|
||||
|
||||
Aws::String m_executionRoleName;
|
||||
bool m_executionRoleNameHasBeenSet = false;
|
||||
|
||||
PermissionModels m_permissionModel;
|
||||
bool m_permissionModelHasBeenSet = false;
|
||||
|
||||
AutoDeployment m_autoDeployment;
|
||||
bool m_autoDeploymentHasBeenSet = false;
|
||||
|
||||
CallAs m_callAs;
|
||||
bool m_callAsHasBeenSet = false;
|
||||
|
||||
Aws::String m_clientRequestToken;
|
||||
bool m_clientRequestTokenHasBeenSet = false;
|
||||
|
||||
ManagedExecution m_managedExecution;
|
||||
bool m_managedExecutionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateStackSetResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API CreateStackSetResult();
|
||||
AWS_CLOUDFORMATION_API CreateStackSetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API CreateStackSetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the stack set that you're creating.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackSetId() const{ return m_stackSetId; }
|
||||
inline void SetStackSetId(const Aws::String& value) { m_stackSetId = value; }
|
||||
inline void SetStackSetId(Aws::String&& value) { m_stackSetId = std::move(value); }
|
||||
inline void SetStackSetId(const char* value) { m_stackSetId.assign(value); }
|
||||
inline CreateStackSetResult& WithStackSetId(const Aws::String& value) { SetStackSetId(value); return *this;}
|
||||
inline CreateStackSetResult& WithStackSetId(Aws::String&& value) { SetStackSetId(std::move(value)); return *this;}
|
||||
inline CreateStackSetResult& WithStackSetId(const char* value) { SetStackSetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline CreateStackSetResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline CreateStackSetResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackSetId;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,40 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeactivateOrganizationsAccessRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeactivateOrganizationsAccessRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DeactivateOrganizationsAccess"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeactivateOrganizationsAccessResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeactivateOrganizationsAccessResult();
|
||||
AWS_CLOUDFORMATION_API DeactivateOrganizationsAccessResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DeactivateOrganizationsAccessResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DeactivateOrganizationsAccessResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DeactivateOrganizationsAccessResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,99 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ThirdPartyType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeactivateTypeRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeactivateTypeRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DeactivateType"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type name of the extension, in this account and Region. If you specified
|
||||
* a type name alias when enabling the extension, use the type name alias.</p>
|
||||
* <p>Conditional: You must specify either <code>Arn</code>, or
|
||||
* <code>TypeName</code> and <code>Type</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTypeName() const{ return m_typeName; }
|
||||
inline bool TypeNameHasBeenSet() const { return m_typeNameHasBeenSet; }
|
||||
inline void SetTypeName(const Aws::String& value) { m_typeNameHasBeenSet = true; m_typeName = value; }
|
||||
inline void SetTypeName(Aws::String&& value) { m_typeNameHasBeenSet = true; m_typeName = std::move(value); }
|
||||
inline void SetTypeName(const char* value) { m_typeNameHasBeenSet = true; m_typeName.assign(value); }
|
||||
inline DeactivateTypeRequest& WithTypeName(const Aws::String& value) { SetTypeName(value); return *this;}
|
||||
inline DeactivateTypeRequest& WithTypeName(Aws::String&& value) { SetTypeName(std::move(value)); return *this;}
|
||||
inline DeactivateTypeRequest& WithTypeName(const char* value) { SetTypeName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The extension type.</p> <p>Conditional: You must specify either
|
||||
* <code>Arn</code>, or <code>TypeName</code> and <code>Type</code>.</p>
|
||||
*/
|
||||
inline const ThirdPartyType& GetType() const{ return m_type; }
|
||||
inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
|
||||
inline void SetType(const ThirdPartyType& value) { m_typeHasBeenSet = true; m_type = value; }
|
||||
inline void SetType(ThirdPartyType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
|
||||
inline DeactivateTypeRequest& WithType(const ThirdPartyType& value) { SetType(value); return *this;}
|
||||
inline DeactivateTypeRequest& WithType(ThirdPartyType&& value) { SetType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) for the extension, in this account and
|
||||
* Region.</p> <p>Conditional: You must specify either <code>Arn</code>, or
|
||||
* <code>TypeName</code> and <code>Type</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetArn() const{ return m_arn; }
|
||||
inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
|
||||
inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
|
||||
inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
|
||||
inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
|
||||
inline DeactivateTypeRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
|
||||
inline DeactivateTypeRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
|
||||
inline DeactivateTypeRequest& WithArn(const char* value) { SetArn(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_typeName;
|
||||
bool m_typeNameHasBeenSet = false;
|
||||
|
||||
ThirdPartyType m_type;
|
||||
bool m_typeHasBeenSet = false;
|
||||
|
||||
Aws::String m_arn;
|
||||
bool m_arnHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeactivateTypeResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeactivateTypeResult();
|
||||
AWS_CLOUDFORMATION_API DeactivateTypeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DeactivateTypeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DeactivateTypeResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DeactivateTypeResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,83 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for the <a>DeleteChangeSet</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DeleteChangeSetInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DeleteChangeSetRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeleteChangeSetRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DeleteChangeSet"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or Amazon Resource Name (ARN) of the change set that you want to
|
||||
* delete.</p>
|
||||
*/
|
||||
inline const Aws::String& GetChangeSetName() const{ return m_changeSetName; }
|
||||
inline bool ChangeSetNameHasBeenSet() const { return m_changeSetNameHasBeenSet; }
|
||||
inline void SetChangeSetName(const Aws::String& value) { m_changeSetNameHasBeenSet = true; m_changeSetName = value; }
|
||||
inline void SetChangeSetName(Aws::String&& value) { m_changeSetNameHasBeenSet = true; m_changeSetName = std::move(value); }
|
||||
inline void SetChangeSetName(const char* value) { m_changeSetNameHasBeenSet = true; m_changeSetName.assign(value); }
|
||||
inline DeleteChangeSetRequest& WithChangeSetName(const Aws::String& value) { SetChangeSetName(value); return *this;}
|
||||
inline DeleteChangeSetRequest& WithChangeSetName(Aws::String&& value) { SetChangeSetName(std::move(value)); return *this;}
|
||||
inline DeleteChangeSetRequest& WithChangeSetName(const char* value) { SetChangeSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If you specified the name of a change set to delete, specify the stack name
|
||||
* or Amazon Resource Name (ARN) that's associated with it.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline DeleteChangeSetRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DeleteChangeSetRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DeleteChangeSetRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_changeSetName;
|
||||
bool m_changeSetNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,56 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The output for the <a>DeleteChangeSet</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DeleteChangeSetOutput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DeleteChangeSetResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeleteChangeSetResult();
|
||||
AWS_CLOUDFORMATION_API DeleteChangeSetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DeleteChangeSetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DeleteChangeSetResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DeleteChangeSetResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteGeneratedTemplateRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeleteGeneratedTemplateRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DeleteGeneratedTemplate"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or Amazon Resource Name (ARN) of a generated template.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGeneratedTemplateName() const{ return m_generatedTemplateName; }
|
||||
inline bool GeneratedTemplateNameHasBeenSet() const { return m_generatedTemplateNameHasBeenSet; }
|
||||
inline void SetGeneratedTemplateName(const Aws::String& value) { m_generatedTemplateNameHasBeenSet = true; m_generatedTemplateName = value; }
|
||||
inline void SetGeneratedTemplateName(Aws::String&& value) { m_generatedTemplateNameHasBeenSet = true; m_generatedTemplateName = std::move(value); }
|
||||
inline void SetGeneratedTemplateName(const char* value) { m_generatedTemplateNameHasBeenSet = true; m_generatedTemplateName.assign(value); }
|
||||
inline DeleteGeneratedTemplateRequest& WithGeneratedTemplateName(const Aws::String& value) { SetGeneratedTemplateName(value); return *this;}
|
||||
inline DeleteGeneratedTemplateRequest& WithGeneratedTemplateName(Aws::String&& value) { SetGeneratedTemplateName(std::move(value)); return *this;}
|
||||
inline DeleteGeneratedTemplateRequest& WithGeneratedTemplateName(const char* value) { SetGeneratedTemplateName(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_generatedTemplateName;
|
||||
bool m_generatedTemplateNameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,204 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/DeploymentTargets.h>
|
||||
#include <aws/cloudformation/model/StackSetOperationPreferences.h>
|
||||
#include <aws/cloudformation/model/CallAs.h>
|
||||
#include <utility>
|
||||
#include <aws/core/utils/UUID.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteStackInstancesRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeleteStackInstancesRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DeleteStackInstances"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or unique ID of the stack set that you want to delete stack
|
||||
* instances for.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackSetName() const{ return m_stackSetName; }
|
||||
inline bool StackSetNameHasBeenSet() const { return m_stackSetNameHasBeenSet; }
|
||||
inline void SetStackSetName(const Aws::String& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = value; }
|
||||
inline void SetStackSetName(Aws::String&& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = std::move(value); }
|
||||
inline void SetStackSetName(const char* value) { m_stackSetNameHasBeenSet = true; m_stackSetName.assign(value); }
|
||||
inline DeleteStackInstancesRequest& WithStackSetName(const Aws::String& value) { SetStackSetName(value); return *this;}
|
||||
inline DeleteStackInstancesRequest& WithStackSetName(Aws::String&& value) { SetStackSetName(std::move(value)); return *this;}
|
||||
inline DeleteStackInstancesRequest& WithStackSetName(const char* value) { SetStackSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Self-managed permissions] The names of the Amazon Web Services accounts that
|
||||
* you want to delete stack instances for.</p> <p>You can specify
|
||||
* <code>Accounts</code> or <code>DeploymentTargets</code>, but not both.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetAccounts() const{ return m_accounts; }
|
||||
inline bool AccountsHasBeenSet() const { return m_accountsHasBeenSet; }
|
||||
inline void SetAccounts(const Aws::Vector<Aws::String>& value) { m_accountsHasBeenSet = true; m_accounts = value; }
|
||||
inline void SetAccounts(Aws::Vector<Aws::String>&& value) { m_accountsHasBeenSet = true; m_accounts = std::move(value); }
|
||||
inline DeleteStackInstancesRequest& WithAccounts(const Aws::Vector<Aws::String>& value) { SetAccounts(value); return *this;}
|
||||
inline DeleteStackInstancesRequest& WithAccounts(Aws::Vector<Aws::String>&& value) { SetAccounts(std::move(value)); return *this;}
|
||||
inline DeleteStackInstancesRequest& AddAccounts(const Aws::String& value) { m_accountsHasBeenSet = true; m_accounts.push_back(value); return *this; }
|
||||
inline DeleteStackInstancesRequest& AddAccounts(Aws::String&& value) { m_accountsHasBeenSet = true; m_accounts.push_back(std::move(value)); return *this; }
|
||||
inline DeleteStackInstancesRequest& AddAccounts(const char* value) { m_accountsHasBeenSet = true; m_accounts.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Service-managed permissions] The Organizations accounts from which to delete
|
||||
* stack instances.</p> <p>You can specify <code>Accounts</code> or
|
||||
* <code>DeploymentTargets</code>, but not both.</p>
|
||||
*/
|
||||
inline const DeploymentTargets& GetDeploymentTargets() const{ return m_deploymentTargets; }
|
||||
inline bool DeploymentTargetsHasBeenSet() const { return m_deploymentTargetsHasBeenSet; }
|
||||
inline void SetDeploymentTargets(const DeploymentTargets& value) { m_deploymentTargetsHasBeenSet = true; m_deploymentTargets = value; }
|
||||
inline void SetDeploymentTargets(DeploymentTargets&& value) { m_deploymentTargetsHasBeenSet = true; m_deploymentTargets = std::move(value); }
|
||||
inline DeleteStackInstancesRequest& WithDeploymentTargets(const DeploymentTargets& value) { SetDeploymentTargets(value); return *this;}
|
||||
inline DeleteStackInstancesRequest& WithDeploymentTargets(DeploymentTargets&& value) { SetDeploymentTargets(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Web Services Regions where you want to delete stack set
|
||||
* instances.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetRegions() const{ return m_regions; }
|
||||
inline bool RegionsHasBeenSet() const { return m_regionsHasBeenSet; }
|
||||
inline void SetRegions(const Aws::Vector<Aws::String>& value) { m_regionsHasBeenSet = true; m_regions = value; }
|
||||
inline void SetRegions(Aws::Vector<Aws::String>&& value) { m_regionsHasBeenSet = true; m_regions = std::move(value); }
|
||||
inline DeleteStackInstancesRequest& WithRegions(const Aws::Vector<Aws::String>& value) { SetRegions(value); return *this;}
|
||||
inline DeleteStackInstancesRequest& WithRegions(Aws::Vector<Aws::String>&& value) { SetRegions(std::move(value)); return *this;}
|
||||
inline DeleteStackInstancesRequest& AddRegions(const Aws::String& value) { m_regionsHasBeenSet = true; m_regions.push_back(value); return *this; }
|
||||
inline DeleteStackInstancesRequest& AddRegions(Aws::String&& value) { m_regionsHasBeenSet = true; m_regions.push_back(std::move(value)); return *this; }
|
||||
inline DeleteStackInstancesRequest& AddRegions(const char* value) { m_regionsHasBeenSet = true; m_regions.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Preferences for how CloudFormation performs this stack set operation.</p>
|
||||
*/
|
||||
inline const StackSetOperationPreferences& GetOperationPreferences() const{ return m_operationPreferences; }
|
||||
inline bool OperationPreferencesHasBeenSet() const { return m_operationPreferencesHasBeenSet; }
|
||||
inline void SetOperationPreferences(const StackSetOperationPreferences& value) { m_operationPreferencesHasBeenSet = true; m_operationPreferences = value; }
|
||||
inline void SetOperationPreferences(StackSetOperationPreferences&& value) { m_operationPreferencesHasBeenSet = true; m_operationPreferences = std::move(value); }
|
||||
inline DeleteStackInstancesRequest& WithOperationPreferences(const StackSetOperationPreferences& value) { SetOperationPreferences(value); return *this;}
|
||||
inline DeleteStackInstancesRequest& WithOperationPreferences(StackSetOperationPreferences&& value) { SetOperationPreferences(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Removes the stack instances from the specified stack set, but doesn't delete
|
||||
* the stacks. You can't reassociate a retained stack or add an existing, saved
|
||||
* stack to a new stack set.</p> <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/what-is-cfnstacksets.html#stackset-ops-options">Stack
|
||||
* set operation options</a>.</p>
|
||||
*/
|
||||
inline bool GetRetainStacks() const{ return m_retainStacks; }
|
||||
inline bool RetainStacksHasBeenSet() const { return m_retainStacksHasBeenSet; }
|
||||
inline void SetRetainStacks(bool value) { m_retainStacksHasBeenSet = true; m_retainStacks = value; }
|
||||
inline DeleteStackInstancesRequest& WithRetainStacks(bool value) { SetRetainStacks(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique identifier for this stack set operation.</p> <p>If you don't
|
||||
* specify an operation ID, the SDK generates one automatically.</p> <p>The
|
||||
* operation ID also functions as an idempotency token, to ensure that
|
||||
* CloudFormation performs the stack set operation only once, even if you retry the
|
||||
* request multiple times. You can retry stack set operation requests to ensure
|
||||
* that CloudFormation successfully received them.</p> <p>Repeating this stack set
|
||||
* operation with a new operation ID retries all stack instances whose status is
|
||||
* <code>OUTDATED</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetOperationId() const{ return m_operationId; }
|
||||
inline bool OperationIdHasBeenSet() const { return m_operationIdHasBeenSet; }
|
||||
inline void SetOperationId(const Aws::String& value) { m_operationIdHasBeenSet = true; m_operationId = value; }
|
||||
inline void SetOperationId(Aws::String&& value) { m_operationIdHasBeenSet = true; m_operationId = std::move(value); }
|
||||
inline void SetOperationId(const char* value) { m_operationIdHasBeenSet = true; m_operationId.assign(value); }
|
||||
inline DeleteStackInstancesRequest& WithOperationId(const Aws::String& value) { SetOperationId(value); return *this;}
|
||||
inline DeleteStackInstancesRequest& WithOperationId(Aws::String&& value) { SetOperationId(std::move(value)); return *this;}
|
||||
inline DeleteStackInstancesRequest& WithOperationId(const char* value) { SetOperationId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Service-managed permissions] Specifies whether you are acting as an account
|
||||
* administrator in the organization's management account or as a delegated
|
||||
* administrator in a member account.</p> <p>By default, <code>SELF</code> is
|
||||
* specified. Use <code>SELF</code> for stack sets with self-managed
|
||||
* permissions.</p> <ul> <li> <p>If you are signed in to the management account,
|
||||
* specify <code>SELF</code>.</p> </li> <li> <p>If you are signed in to a delegated
|
||||
* administrator account, specify <code>DELEGATED_ADMIN</code>.</p> <p>Your Amazon
|
||||
* Web Services account must be registered as a delegated administrator in the
|
||||
* management account. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html">Register
|
||||
* a delegated administrator</a> in the <i>CloudFormation User Guide</i>.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const CallAs& GetCallAs() const{ return m_callAs; }
|
||||
inline bool CallAsHasBeenSet() const { return m_callAsHasBeenSet; }
|
||||
inline void SetCallAs(const CallAs& value) { m_callAsHasBeenSet = true; m_callAs = value; }
|
||||
inline void SetCallAs(CallAs&& value) { m_callAsHasBeenSet = true; m_callAs = std::move(value); }
|
||||
inline DeleteStackInstancesRequest& WithCallAs(const CallAs& value) { SetCallAs(value); return *this;}
|
||||
inline DeleteStackInstancesRequest& WithCallAs(CallAs&& value) { SetCallAs(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackSetName;
|
||||
bool m_stackSetNameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_accounts;
|
||||
bool m_accountsHasBeenSet = false;
|
||||
|
||||
DeploymentTargets m_deploymentTargets;
|
||||
bool m_deploymentTargetsHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_regions;
|
||||
bool m_regionsHasBeenSet = false;
|
||||
|
||||
StackSetOperationPreferences m_operationPreferences;
|
||||
bool m_operationPreferencesHasBeenSet = false;
|
||||
|
||||
bool m_retainStacks;
|
||||
bool m_retainStacksHasBeenSet = false;
|
||||
|
||||
Aws::String m_operationId;
|
||||
bool m_operationIdHasBeenSet = false;
|
||||
|
||||
CallAs m_callAs;
|
||||
bool m_callAsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeleteStackInstancesResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeleteStackInstancesResult();
|
||||
AWS_CLOUDFORMATION_API DeleteStackInstancesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DeleteStackInstancesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique identifier for this stack set operation.</p>
|
||||
*/
|
||||
inline const Aws::String& GetOperationId() const{ return m_operationId; }
|
||||
inline void SetOperationId(const Aws::String& value) { m_operationId = value; }
|
||||
inline void SetOperationId(Aws::String&& value) { m_operationId = std::move(value); }
|
||||
inline void SetOperationId(const char* value) { m_operationId.assign(value); }
|
||||
inline DeleteStackInstancesResult& WithOperationId(const Aws::String& value) { SetOperationId(value); return *this;}
|
||||
inline DeleteStackInstancesResult& WithOperationId(Aws::String&& value) { SetOperationId(std::move(value)); return *this;}
|
||||
inline DeleteStackInstancesResult& WithOperationId(const char* value) { SetOperationId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DeleteStackInstancesResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DeleteStackInstancesResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_operationId;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,161 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/DeletionMode.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for <a>DeleteStack</a> action.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DeleteStackInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DeleteStackRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeleteStackRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DeleteStack"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or the unique stack ID that's associated with the stack.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline DeleteStackRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DeleteStackRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DeleteStackRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>For stacks in the <code>DELETE_FAILED</code> state, a list of resource
|
||||
* logical IDs that are associated with the resources you want to retain. During
|
||||
* deletion, CloudFormation deletes the stack but doesn't delete the retained
|
||||
* resources.</p> <p>Retaining resources is useful when you can't delete a
|
||||
* resource, such as a non-empty S3 bucket, but you want to delete the stack.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetRetainResources() const{ return m_retainResources; }
|
||||
inline bool RetainResourcesHasBeenSet() const { return m_retainResourcesHasBeenSet; }
|
||||
inline void SetRetainResources(const Aws::Vector<Aws::String>& value) { m_retainResourcesHasBeenSet = true; m_retainResources = value; }
|
||||
inline void SetRetainResources(Aws::Vector<Aws::String>&& value) { m_retainResourcesHasBeenSet = true; m_retainResources = std::move(value); }
|
||||
inline DeleteStackRequest& WithRetainResources(const Aws::Vector<Aws::String>& value) { SetRetainResources(value); return *this;}
|
||||
inline DeleteStackRequest& WithRetainResources(Aws::Vector<Aws::String>&& value) { SetRetainResources(std::move(value)); return *this;}
|
||||
inline DeleteStackRequest& AddRetainResources(const Aws::String& value) { m_retainResourcesHasBeenSet = true; m_retainResources.push_back(value); return *this; }
|
||||
inline DeleteStackRequest& AddRetainResources(Aws::String&& value) { m_retainResourcesHasBeenSet = true; m_retainResources.push_back(std::move(value)); return *this; }
|
||||
inline DeleteStackRequest& AddRetainResources(const char* value) { m_retainResourcesHasBeenSet = true; m_retainResources.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of an IAM role that CloudFormation assumes to
|
||||
* delete the stack. CloudFormation uses the role's credentials to make calls on
|
||||
* your behalf.</p> <p>If you don't specify a value, CloudFormation uses the role
|
||||
* that was previously associated with the stack. If no role is available,
|
||||
* CloudFormation uses a temporary session that's generated from your user
|
||||
* credentials.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRoleARN() const{ return m_roleARN; }
|
||||
inline bool RoleARNHasBeenSet() const { return m_roleARNHasBeenSet; }
|
||||
inline void SetRoleARN(const Aws::String& value) { m_roleARNHasBeenSet = true; m_roleARN = value; }
|
||||
inline void SetRoleARN(Aws::String&& value) { m_roleARNHasBeenSet = true; m_roleARN = std::move(value); }
|
||||
inline void SetRoleARN(const char* value) { m_roleARNHasBeenSet = true; m_roleARN.assign(value); }
|
||||
inline DeleteStackRequest& WithRoleARN(const Aws::String& value) { SetRoleARN(value); return *this;}
|
||||
inline DeleteStackRequest& WithRoleARN(Aws::String&& value) { SetRoleARN(std::move(value)); return *this;}
|
||||
inline DeleteStackRequest& WithRoleARN(const char* value) { SetRoleARN(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for this <code>DeleteStack</code> request. Specify this
|
||||
* token if you plan to retry requests so that CloudFormation knows that you're not
|
||||
* attempting to delete a stack with the same name. You might retry
|
||||
* <code>DeleteStack</code> requests to ensure that CloudFormation successfully
|
||||
* received them.</p> <p>All events initiated by a given stack operation are
|
||||
* assigned the same client request token, which you can use to track operations.
|
||||
* For example, if you execute a <code>CreateStack</code> operation with the token
|
||||
* <code>token1</code>, then all the <code>StackEvents</code> generated by that
|
||||
* operation will have <code>ClientRequestToken</code> set as
|
||||
* <code>token1</code>.</p> <p>In the console, stack operations display the client
|
||||
* request token on the Events tab. Stack operations that are initiated from the
|
||||
* console use the token format <i>Console-StackOperation-ID</i>, which helps you
|
||||
* easily identify the stack operation . For example, if you create a stack using
|
||||
* the console, each stack event would be assigned the same token in the following
|
||||
* format:
|
||||
* <code>Console-CreateStack-7f59c3cf-00d2-40c7-b2ff-e75db0987002</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetClientRequestToken() const{ return m_clientRequestToken; }
|
||||
inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
|
||||
inline void SetClientRequestToken(const Aws::String& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = value; }
|
||||
inline void SetClientRequestToken(Aws::String&& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = std::move(value); }
|
||||
inline void SetClientRequestToken(const char* value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken.assign(value); }
|
||||
inline DeleteStackRequest& WithClientRequestToken(const Aws::String& value) { SetClientRequestToken(value); return *this;}
|
||||
inline DeleteStackRequest& WithClientRequestToken(Aws::String&& value) { SetClientRequestToken(std::move(value)); return *this;}
|
||||
inline DeleteStackRequest& WithClientRequestToken(const char* value) { SetClientRequestToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Specifies the deletion mode for the stack. Possible values are:</p> <ul> <li>
|
||||
* <p> <code>STANDARD</code> - Use the standard behavior. Specifying this value is
|
||||
* the same as not specifying this parameter.</p> </li> <li> <p>
|
||||
* <code>FORCE_DELETE_STACK</code> - Delete the stack if it's stuck in a
|
||||
* <code>DELETE_FAILED</code> state due to resource deletion failure.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const DeletionMode& GetDeletionMode() const{ return m_deletionMode; }
|
||||
inline bool DeletionModeHasBeenSet() const { return m_deletionModeHasBeenSet; }
|
||||
inline void SetDeletionMode(const DeletionMode& value) { m_deletionModeHasBeenSet = true; m_deletionMode = value; }
|
||||
inline void SetDeletionMode(DeletionMode&& value) { m_deletionModeHasBeenSet = true; m_deletionMode = std::move(value); }
|
||||
inline DeleteStackRequest& WithDeletionMode(const DeletionMode& value) { SetDeletionMode(value); return *this;}
|
||||
inline DeleteStackRequest& WithDeletionMode(DeletionMode&& value) { SetDeletionMode(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_retainResources;
|
||||
bool m_retainResourcesHasBeenSet = false;
|
||||
|
||||
Aws::String m_roleARN;
|
||||
bool m_roleARNHasBeenSet = false;
|
||||
|
||||
Aws::String m_clientRequestToken;
|
||||
bool m_clientRequestTokenHasBeenSet = false;
|
||||
|
||||
DeletionMode m_deletionMode;
|
||||
bool m_deletionModeHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,88 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/CallAs.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteStackSetRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeleteStackSetRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DeleteStackSet"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or unique ID of the stack set that you're deleting. You can obtain
|
||||
* this value by running <a>ListStackSets</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackSetName() const{ return m_stackSetName; }
|
||||
inline bool StackSetNameHasBeenSet() const { return m_stackSetNameHasBeenSet; }
|
||||
inline void SetStackSetName(const Aws::String& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = value; }
|
||||
inline void SetStackSetName(Aws::String&& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = std::move(value); }
|
||||
inline void SetStackSetName(const char* value) { m_stackSetNameHasBeenSet = true; m_stackSetName.assign(value); }
|
||||
inline DeleteStackSetRequest& WithStackSetName(const Aws::String& value) { SetStackSetName(value); return *this;}
|
||||
inline DeleteStackSetRequest& WithStackSetName(Aws::String&& value) { SetStackSetName(std::move(value)); return *this;}
|
||||
inline DeleteStackSetRequest& WithStackSetName(const char* value) { SetStackSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Service-managed permissions] Specifies whether you are acting as an account
|
||||
* administrator in the organization's management account or as a delegated
|
||||
* administrator in a member account.</p> <p>By default, <code>SELF</code> is
|
||||
* specified. Use <code>SELF</code> for stack sets with self-managed
|
||||
* permissions.</p> <ul> <li> <p>If you are signed in to the management account,
|
||||
* specify <code>SELF</code>.</p> </li> <li> <p>If you are signed in to a delegated
|
||||
* administrator account, specify <code>DELEGATED_ADMIN</code>.</p> <p>Your Amazon
|
||||
* Web Services account must be registered as a delegated administrator in the
|
||||
* management account. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html">Register
|
||||
* a delegated administrator</a> in the <i>CloudFormation User Guide</i>.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const CallAs& GetCallAs() const{ return m_callAs; }
|
||||
inline bool CallAsHasBeenSet() const { return m_callAsHasBeenSet; }
|
||||
inline void SetCallAs(const CallAs& value) { m_callAsHasBeenSet = true; m_callAs = value; }
|
||||
inline void SetCallAs(CallAs&& value) { m_callAsHasBeenSet = true; m_callAs = std::move(value); }
|
||||
inline DeleteStackSetRequest& WithCallAs(const CallAs& value) { SetCallAs(value); return *this;}
|
||||
inline DeleteStackSetRequest& WithCallAs(CallAs&& value) { SetCallAs(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackSetName;
|
||||
bool m_stackSetNameHasBeenSet = false;
|
||||
|
||||
CallAs m_callAs;
|
||||
bool m_callAsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeleteStackSetResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeleteStackSetResult();
|
||||
AWS_CLOUDFORMATION_API DeleteStackSetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DeleteStackSetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DeleteStackSetResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DeleteStackSetResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class DeletionMode
|
||||
{
|
||||
NOT_SET,
|
||||
STANDARD,
|
||||
FORCE_DELETE_STACK
|
||||
};
|
||||
|
||||
namespace DeletionModeMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API DeletionMode GetDeletionModeForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForDeletionMode(DeletionMode value);
|
||||
} // namespace DeletionModeMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,136 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/AccountFilterType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlNode;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>[Service-managed permissions] The Organizations accounts to which StackSets
|
||||
* deploys. StackSets doesn't deploy stack instances to the organization management
|
||||
* account, even if the organization management account is in your organization or
|
||||
* in an OU in your organization.</p> <p>For update operations, you can specify
|
||||
* either <code>Accounts</code> or <code>OrganizationalUnitIds</code>. For create
|
||||
* and delete operations, specify <code>OrganizationalUnitIds</code>.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DeploymentTargets">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DeploymentTargets
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeploymentTargets();
|
||||
AWS_CLOUDFORMATION_API DeploymentTargets(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
AWS_CLOUDFORMATION_API DeploymentTargets& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
|
||||
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
|
||||
AWS_CLOUDFORMATION_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The names of one or more Amazon Web Services accounts for which you want to
|
||||
* deploy stack set updates.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetAccounts() const{ return m_accounts; }
|
||||
inline bool AccountsHasBeenSet() const { return m_accountsHasBeenSet; }
|
||||
inline void SetAccounts(const Aws::Vector<Aws::String>& value) { m_accountsHasBeenSet = true; m_accounts = value; }
|
||||
inline void SetAccounts(Aws::Vector<Aws::String>&& value) { m_accountsHasBeenSet = true; m_accounts = std::move(value); }
|
||||
inline DeploymentTargets& WithAccounts(const Aws::Vector<Aws::String>& value) { SetAccounts(value); return *this;}
|
||||
inline DeploymentTargets& WithAccounts(Aws::Vector<Aws::String>&& value) { SetAccounts(std::move(value)); return *this;}
|
||||
inline DeploymentTargets& AddAccounts(const Aws::String& value) { m_accountsHasBeenSet = true; m_accounts.push_back(value); return *this; }
|
||||
inline DeploymentTargets& AddAccounts(Aws::String&& value) { m_accountsHasBeenSet = true; m_accounts.push_back(std::move(value)); return *this; }
|
||||
inline DeploymentTargets& AddAccounts(const char* value) { m_accountsHasBeenSet = true; m_accounts.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Returns the value of the <code>AccountsUrl</code> property.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAccountsUrl() const{ return m_accountsUrl; }
|
||||
inline bool AccountsUrlHasBeenSet() const { return m_accountsUrlHasBeenSet; }
|
||||
inline void SetAccountsUrl(const Aws::String& value) { m_accountsUrlHasBeenSet = true; m_accountsUrl = value; }
|
||||
inline void SetAccountsUrl(Aws::String&& value) { m_accountsUrlHasBeenSet = true; m_accountsUrl = std::move(value); }
|
||||
inline void SetAccountsUrl(const char* value) { m_accountsUrlHasBeenSet = true; m_accountsUrl.assign(value); }
|
||||
inline DeploymentTargets& WithAccountsUrl(const Aws::String& value) { SetAccountsUrl(value); return *this;}
|
||||
inline DeploymentTargets& WithAccountsUrl(Aws::String&& value) { SetAccountsUrl(std::move(value)); return *this;}
|
||||
inline DeploymentTargets& WithAccountsUrl(const char* value) { SetAccountsUrl(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The organization root ID or organizational unit (OU) IDs to which StackSets
|
||||
* deploys.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetOrganizationalUnitIds() const{ return m_organizationalUnitIds; }
|
||||
inline bool OrganizationalUnitIdsHasBeenSet() const { return m_organizationalUnitIdsHasBeenSet; }
|
||||
inline void SetOrganizationalUnitIds(const Aws::Vector<Aws::String>& value) { m_organizationalUnitIdsHasBeenSet = true; m_organizationalUnitIds = value; }
|
||||
inline void SetOrganizationalUnitIds(Aws::Vector<Aws::String>&& value) { m_organizationalUnitIdsHasBeenSet = true; m_organizationalUnitIds = std::move(value); }
|
||||
inline DeploymentTargets& WithOrganizationalUnitIds(const Aws::Vector<Aws::String>& value) { SetOrganizationalUnitIds(value); return *this;}
|
||||
inline DeploymentTargets& WithOrganizationalUnitIds(Aws::Vector<Aws::String>&& value) { SetOrganizationalUnitIds(std::move(value)); return *this;}
|
||||
inline DeploymentTargets& AddOrganizationalUnitIds(const Aws::String& value) { m_organizationalUnitIdsHasBeenSet = true; m_organizationalUnitIds.push_back(value); return *this; }
|
||||
inline DeploymentTargets& AddOrganizationalUnitIds(Aws::String&& value) { m_organizationalUnitIdsHasBeenSet = true; m_organizationalUnitIds.push_back(std::move(value)); return *this; }
|
||||
inline DeploymentTargets& AddOrganizationalUnitIds(const char* value) { m_organizationalUnitIdsHasBeenSet = true; m_organizationalUnitIds.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Limit deployment targets to individual accounts or include additional
|
||||
* accounts with provided OUs.</p> <p>The following is a list of possible values
|
||||
* for the <code>AccountFilterType</code> operation.</p> <ul> <li> <p>
|
||||
* <code>INTERSECTION</code>: StackSets deploys to the accounts specified in
|
||||
* <code>Accounts</code> parameter. </p> </li> <li> <p> <code>DIFFERENCE</code>:
|
||||
* StackSets excludes the accounts specified in <code>Accounts</code> parameter.
|
||||
* This enables user to avoid certain accounts within an OU such as suspended
|
||||
* accounts.</p> </li> <li> <p> <code>UNION</code>: StackSets includes additional
|
||||
* accounts deployment targets. </p> <p>This is the default value if
|
||||
* <code>AccountFilterType</code> is not provided. This enables user to update an
|
||||
* entire OU and individual accounts from a different OU in one request, which used
|
||||
* to be two separate requests.</p> </li> <li> <p> <code>NONE</code>: Deploys to
|
||||
* all the accounts in specified organizational units (OU).</p> </li> </ul>
|
||||
*/
|
||||
inline const AccountFilterType& GetAccountFilterType() const{ return m_accountFilterType; }
|
||||
inline bool AccountFilterTypeHasBeenSet() const { return m_accountFilterTypeHasBeenSet; }
|
||||
inline void SetAccountFilterType(const AccountFilterType& value) { m_accountFilterTypeHasBeenSet = true; m_accountFilterType = value; }
|
||||
inline void SetAccountFilterType(AccountFilterType&& value) { m_accountFilterTypeHasBeenSet = true; m_accountFilterType = std::move(value); }
|
||||
inline DeploymentTargets& WithAccountFilterType(const AccountFilterType& value) { SetAccountFilterType(value); return *this;}
|
||||
inline DeploymentTargets& WithAccountFilterType(AccountFilterType&& value) { SetAccountFilterType(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<Aws::String> m_accounts;
|
||||
bool m_accountsHasBeenSet = false;
|
||||
|
||||
Aws::String m_accountsUrl;
|
||||
bool m_accountsUrlHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_organizationalUnitIds;
|
||||
bool m_organizationalUnitIdsHasBeenSet = false;
|
||||
|
||||
AccountFilterType m_accountFilterType;
|
||||
bool m_accountFilterTypeHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class DeprecatedStatus
|
||||
{
|
||||
NOT_SET,
|
||||
LIVE,
|
||||
DEPRECATED
|
||||
};
|
||||
|
||||
namespace DeprecatedStatusMapper
|
||||
{
|
||||
AWS_CLOUDFORMATION_API DeprecatedStatus GetDeprecatedStatusForName(const Aws::String& name);
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String GetNameForDeprecatedStatus(DeprecatedStatus value);
|
||||
} // namespace DeprecatedStatusMapper
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,116 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/RegistryType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeregisterTypeRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeregisterTypeRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DeregisterType"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the extension.</p> <p>Conditional: You must
|
||||
* specify either <code>TypeName</code> and <code>Type</code>, or
|
||||
* <code>Arn</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetArn() const{ return m_arn; }
|
||||
inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
|
||||
inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
|
||||
inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
|
||||
inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
|
||||
inline DeregisterTypeRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
|
||||
inline DeregisterTypeRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
|
||||
inline DeregisterTypeRequest& WithArn(const char* value) { SetArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The kind of extension.</p> <p>Conditional: You must specify either
|
||||
* <code>TypeName</code> and <code>Type</code>, or <code>Arn</code>.</p>
|
||||
*/
|
||||
inline const RegistryType& GetType() const{ return m_type; }
|
||||
inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
|
||||
inline void SetType(const RegistryType& value) { m_typeHasBeenSet = true; m_type = value; }
|
||||
inline void SetType(RegistryType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
|
||||
inline DeregisterTypeRequest& WithType(const RegistryType& value) { SetType(value); return *this;}
|
||||
inline DeregisterTypeRequest& WithType(RegistryType&& value) { SetType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the extension.</p> <p>Conditional: You must specify either
|
||||
* <code>TypeName</code> and <code>Type</code>, or <code>Arn</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTypeName() const{ return m_typeName; }
|
||||
inline bool TypeNameHasBeenSet() const { return m_typeNameHasBeenSet; }
|
||||
inline void SetTypeName(const Aws::String& value) { m_typeNameHasBeenSet = true; m_typeName = value; }
|
||||
inline void SetTypeName(Aws::String&& value) { m_typeNameHasBeenSet = true; m_typeName = std::move(value); }
|
||||
inline void SetTypeName(const char* value) { m_typeNameHasBeenSet = true; m_typeName.assign(value); }
|
||||
inline DeregisterTypeRequest& WithTypeName(const Aws::String& value) { SetTypeName(value); return *this;}
|
||||
inline DeregisterTypeRequest& WithTypeName(Aws::String&& value) { SetTypeName(std::move(value)); return *this;}
|
||||
inline DeregisterTypeRequest& WithTypeName(const char* value) { SetTypeName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of a specific version of the extension. The version ID is the value at
|
||||
* the end of the Amazon Resource Name (ARN) assigned to the extension version when
|
||||
* it is registered.</p>
|
||||
*/
|
||||
inline const Aws::String& GetVersionId() const{ return m_versionId; }
|
||||
inline bool VersionIdHasBeenSet() const { return m_versionIdHasBeenSet; }
|
||||
inline void SetVersionId(const Aws::String& value) { m_versionIdHasBeenSet = true; m_versionId = value; }
|
||||
inline void SetVersionId(Aws::String&& value) { m_versionIdHasBeenSet = true; m_versionId = std::move(value); }
|
||||
inline void SetVersionId(const char* value) { m_versionIdHasBeenSet = true; m_versionId.assign(value); }
|
||||
inline DeregisterTypeRequest& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
|
||||
inline DeregisterTypeRequest& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
|
||||
inline DeregisterTypeRequest& WithVersionId(const char* value) { SetVersionId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_arn;
|
||||
bool m_arnHasBeenSet = false;
|
||||
|
||||
RegistryType m_type;
|
||||
bool m_typeHasBeenSet = false;
|
||||
|
||||
Aws::String m_typeName;
|
||||
bool m_typeNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_versionId;
|
||||
bool m_versionIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeregisterTypeResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DeregisterTypeResult();
|
||||
AWS_CLOUDFORMATION_API DeregisterTypeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DeregisterTypeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DeregisterTypeResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DeregisterTypeResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,65 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for the <a>DescribeAccountLimits</a> action.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeAccountLimitsInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeAccountLimitsRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeAccountLimitsRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeAccountLimits"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A string that identifies the next page of limits that you want to
|
||||
* retrieve.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
|
||||
inline DescribeAccountLimitsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeAccountLimitsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeAccountLimitsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_nextToken;
|
||||
bool m_nextTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,91 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <aws/cloudformation/model/AccountLimit.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The output for the <a>DescribeAccountLimits</a> action.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeAccountLimitsOutput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeAccountLimitsResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeAccountLimitsResult();
|
||||
AWS_CLOUDFORMATION_API DescribeAccountLimitsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeAccountLimitsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An account limit structure that contain a list of CloudFormation account
|
||||
* limits and their values.</p>
|
||||
*/
|
||||
inline const Aws::Vector<AccountLimit>& GetAccountLimits() const{ return m_accountLimits; }
|
||||
inline void SetAccountLimits(const Aws::Vector<AccountLimit>& value) { m_accountLimits = value; }
|
||||
inline void SetAccountLimits(Aws::Vector<AccountLimit>&& value) { m_accountLimits = std::move(value); }
|
||||
inline DescribeAccountLimitsResult& WithAccountLimits(const Aws::Vector<AccountLimit>& value) { SetAccountLimits(value); return *this;}
|
||||
inline DescribeAccountLimitsResult& WithAccountLimits(Aws::Vector<AccountLimit>&& value) { SetAccountLimits(std::move(value)); return *this;}
|
||||
inline DescribeAccountLimitsResult& AddAccountLimits(const AccountLimit& value) { m_accountLimits.push_back(value); return *this; }
|
||||
inline DescribeAccountLimitsResult& AddAccountLimits(AccountLimit&& value) { m_accountLimits.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If the output exceeds 1 MB in size, a string that identifies the next page of
|
||||
* limits. If no additional page exists, this value is null.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
|
||||
inline DescribeAccountLimitsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeAccountLimitsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeAccountLimitsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeAccountLimitsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeAccountLimitsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<AccountLimit> m_accountLimits;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,116 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribeChangeSetHooksRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeChangeSetHooksRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeChangeSetHooks"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or Amazon Resource Name (ARN) of the change set that you want to
|
||||
* describe.</p>
|
||||
*/
|
||||
inline const Aws::String& GetChangeSetName() const{ return m_changeSetName; }
|
||||
inline bool ChangeSetNameHasBeenSet() const { return m_changeSetNameHasBeenSet; }
|
||||
inline void SetChangeSetName(const Aws::String& value) { m_changeSetNameHasBeenSet = true; m_changeSetName = value; }
|
||||
inline void SetChangeSetName(Aws::String&& value) { m_changeSetNameHasBeenSet = true; m_changeSetName = std::move(value); }
|
||||
inline void SetChangeSetName(const char* value) { m_changeSetNameHasBeenSet = true; m_changeSetName.assign(value); }
|
||||
inline DescribeChangeSetHooksRequest& WithChangeSetName(const Aws::String& value) { SetChangeSetName(value); return *this;}
|
||||
inline DescribeChangeSetHooksRequest& WithChangeSetName(Aws::String&& value) { SetChangeSetName(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetHooksRequest& WithChangeSetName(const char* value) { SetChangeSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If you specified the name of a change set, specify the stack name or stack ID
|
||||
* (ARN) of the change set you want to describe.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline DescribeChangeSetHooksRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DescribeChangeSetHooksRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetHooksRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A string, provided by the <code>DescribeChangeSetHooks</code> response
|
||||
* output, that identifies the next page of information that you want to
|
||||
* retrieve.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
|
||||
inline DescribeChangeSetHooksRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeChangeSetHooksRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetHooksRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If specified, lists only the hooks related to the specified
|
||||
* <code>LogicalResourceId</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetLogicalResourceId() const{ return m_logicalResourceId; }
|
||||
inline bool LogicalResourceIdHasBeenSet() const { return m_logicalResourceIdHasBeenSet; }
|
||||
inline void SetLogicalResourceId(const Aws::String& value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId = value; }
|
||||
inline void SetLogicalResourceId(Aws::String&& value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId = std::move(value); }
|
||||
inline void SetLogicalResourceId(const char* value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId.assign(value); }
|
||||
inline DescribeChangeSetHooksRequest& WithLogicalResourceId(const Aws::String& value) { SetLogicalResourceId(value); return *this;}
|
||||
inline DescribeChangeSetHooksRequest& WithLogicalResourceId(Aws::String&& value) { SetLogicalResourceId(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetHooksRequest& WithLogicalResourceId(const char* value) { SetLogicalResourceId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_changeSetName;
|
||||
bool m_changeSetNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
bool m_nextTokenHasBeenSet = false;
|
||||
|
||||
Aws::String m_logicalResourceId;
|
||||
bool m_logicalResourceIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,157 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/ChangeSetHooksStatus.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <aws/cloudformation/model/ChangeSetHook.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribeChangeSetHooksResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeChangeSetHooksResult();
|
||||
AWS_CLOUDFORMATION_API DescribeChangeSetHooksResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeChangeSetHooksResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The change set identifier (stack ID).</p>
|
||||
*/
|
||||
inline const Aws::String& GetChangeSetId() const{ return m_changeSetId; }
|
||||
inline void SetChangeSetId(const Aws::String& value) { m_changeSetId = value; }
|
||||
inline void SetChangeSetId(Aws::String&& value) { m_changeSetId = std::move(value); }
|
||||
inline void SetChangeSetId(const char* value) { m_changeSetId.assign(value); }
|
||||
inline DescribeChangeSetHooksResult& WithChangeSetId(const Aws::String& value) { SetChangeSetId(value); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithChangeSetId(Aws::String&& value) { SetChangeSetId(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithChangeSetId(const char* value) { SetChangeSetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The change set name.</p>
|
||||
*/
|
||||
inline const Aws::String& GetChangeSetName() const{ return m_changeSetName; }
|
||||
inline void SetChangeSetName(const Aws::String& value) { m_changeSetName = value; }
|
||||
inline void SetChangeSetName(Aws::String&& value) { m_changeSetName = std::move(value); }
|
||||
inline void SetChangeSetName(const char* value) { m_changeSetName.assign(value); }
|
||||
inline DescribeChangeSetHooksResult& WithChangeSetName(const Aws::String& value) { SetChangeSetName(value); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithChangeSetName(Aws::String&& value) { SetChangeSetName(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithChangeSetName(const char* value) { SetChangeSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>List of hook objects.</p>
|
||||
*/
|
||||
inline const Aws::Vector<ChangeSetHook>& GetHooks() const{ return m_hooks; }
|
||||
inline void SetHooks(const Aws::Vector<ChangeSetHook>& value) { m_hooks = value; }
|
||||
inline void SetHooks(Aws::Vector<ChangeSetHook>&& value) { m_hooks = std::move(value); }
|
||||
inline DescribeChangeSetHooksResult& WithHooks(const Aws::Vector<ChangeSetHook>& value) { SetHooks(value); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithHooks(Aws::Vector<ChangeSetHook>&& value) { SetHooks(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetHooksResult& AddHooks(const ChangeSetHook& value) { m_hooks.push_back(value); return *this; }
|
||||
inline DescribeChangeSetHooksResult& AddHooks(ChangeSetHook&& value) { m_hooks.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Provides the status of the change set hook.</p>
|
||||
*/
|
||||
inline const ChangeSetHooksStatus& GetStatus() const{ return m_status; }
|
||||
inline void SetStatus(const ChangeSetHooksStatus& value) { m_status = value; }
|
||||
inline void SetStatus(ChangeSetHooksStatus&& value) { m_status = std::move(value); }
|
||||
inline DescribeChangeSetHooksResult& WithStatus(const ChangeSetHooksStatus& value) { SetStatus(value); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithStatus(ChangeSetHooksStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Pagination token, <code>null</code> or empty if no more results.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
|
||||
inline DescribeChangeSetHooksResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The stack identifier (stack ID).</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackId() const{ return m_stackId; }
|
||||
inline void SetStackId(const Aws::String& value) { m_stackId = value; }
|
||||
inline void SetStackId(Aws::String&& value) { m_stackId = std::move(value); }
|
||||
inline void SetStackId(const char* value) { m_stackId.assign(value); }
|
||||
inline DescribeChangeSetHooksResult& WithStackId(const Aws::String& value) { SetStackId(value); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithStackId(Aws::String&& value) { SetStackId(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithStackId(const char* value) { SetStackId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The stack name.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackName.assign(value); }
|
||||
inline DescribeChangeSetHooksResult& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeChangeSetHooksResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeChangeSetHooksResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_changeSetId;
|
||||
|
||||
Aws::String m_changeSetName;
|
||||
|
||||
Aws::Vector<ChangeSetHook> m_hooks;
|
||||
|
||||
ChangeSetHooksStatus m_status;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
|
||||
Aws::String m_stackId;
|
||||
|
||||
Aws::String m_stackName;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,115 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for the <a>DescribeChangeSet</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeChangeSetInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeChangeSetRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeChangeSetRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeChangeSet"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or Amazon Resource Name (ARN) of the change set that you want to
|
||||
* describe.</p>
|
||||
*/
|
||||
inline const Aws::String& GetChangeSetName() const{ return m_changeSetName; }
|
||||
inline bool ChangeSetNameHasBeenSet() const { return m_changeSetNameHasBeenSet; }
|
||||
inline void SetChangeSetName(const Aws::String& value) { m_changeSetNameHasBeenSet = true; m_changeSetName = value; }
|
||||
inline void SetChangeSetName(Aws::String&& value) { m_changeSetNameHasBeenSet = true; m_changeSetName = std::move(value); }
|
||||
inline void SetChangeSetName(const char* value) { m_changeSetNameHasBeenSet = true; m_changeSetName.assign(value); }
|
||||
inline DescribeChangeSetRequest& WithChangeSetName(const Aws::String& value) { SetChangeSetName(value); return *this;}
|
||||
inline DescribeChangeSetRequest& WithChangeSetName(Aws::String&& value) { SetChangeSetName(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetRequest& WithChangeSetName(const char* value) { SetChangeSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If you specified the name of a change set, specify the stack name or ID (ARN)
|
||||
* of the change set you want to describe.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline DescribeChangeSetRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DescribeChangeSetRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A string (provided by the <a>DescribeChangeSet</a> response output) that
|
||||
* identifies the next page of information that you want to retrieve.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
|
||||
inline DescribeChangeSetRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeChangeSetRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If <code>true</code>, the returned changes include detailed changes in the
|
||||
* property values.</p>
|
||||
*/
|
||||
inline bool GetIncludePropertyValues() const{ return m_includePropertyValues; }
|
||||
inline bool IncludePropertyValuesHasBeenSet() const { return m_includePropertyValuesHasBeenSet; }
|
||||
inline void SetIncludePropertyValues(bool value) { m_includePropertyValuesHasBeenSet = true; m_includePropertyValues = value; }
|
||||
inline DescribeChangeSetRequest& WithIncludePropertyValues(bool value) { SetIncludePropertyValues(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_changeSetName;
|
||||
bool m_changeSetNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
bool m_nextTokenHasBeenSet = false;
|
||||
|
||||
bool m_includePropertyValues;
|
||||
bool m_includePropertyValuesHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,406 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <aws/cloudformation/model/ExecutionStatus.h>
|
||||
#include <aws/cloudformation/model/ChangeSetStatus.h>
|
||||
#include <aws/cloudformation/model/RollbackConfiguration.h>
|
||||
#include <aws/cloudformation/model/OnStackFailure.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <aws/cloudformation/model/Parameter.h>
|
||||
#include <aws/cloudformation/model/Capability.h>
|
||||
#include <aws/cloudformation/model/Tag.h>
|
||||
#include <aws/cloudformation/model/Change.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The output for the <a>DescribeChangeSet</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeChangeSetOutput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeChangeSetResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeChangeSetResult();
|
||||
AWS_CLOUDFORMATION_API DescribeChangeSetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeChangeSetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the change set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetChangeSetName() const{ return m_changeSetName; }
|
||||
inline void SetChangeSetName(const Aws::String& value) { m_changeSetName = value; }
|
||||
inline void SetChangeSetName(Aws::String&& value) { m_changeSetName = std::move(value); }
|
||||
inline void SetChangeSetName(const char* value) { m_changeSetName.assign(value); }
|
||||
inline DescribeChangeSetResult& WithChangeSetName(const Aws::String& value) { SetChangeSetName(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithChangeSetName(Aws::String&& value) { SetChangeSetName(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& WithChangeSetName(const char* value) { SetChangeSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the change set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetChangeSetId() const{ return m_changeSetId; }
|
||||
inline void SetChangeSetId(const Aws::String& value) { m_changeSetId = value; }
|
||||
inline void SetChangeSetId(Aws::String&& value) { m_changeSetId = std::move(value); }
|
||||
inline void SetChangeSetId(const char* value) { m_changeSetId.assign(value); }
|
||||
inline DescribeChangeSetResult& WithChangeSetId(const Aws::String& value) { SetChangeSetId(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithChangeSetId(Aws::String&& value) { SetChangeSetId(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& WithChangeSetId(const char* value) { SetChangeSetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the stack that's associated with the change
|
||||
* set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackId() const{ return m_stackId; }
|
||||
inline void SetStackId(const Aws::String& value) { m_stackId = value; }
|
||||
inline void SetStackId(Aws::String&& value) { m_stackId = std::move(value); }
|
||||
inline void SetStackId(const char* value) { m_stackId.assign(value); }
|
||||
inline DescribeChangeSetResult& WithStackId(const Aws::String& value) { SetStackId(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithStackId(Aws::String&& value) { SetStackId(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& WithStackId(const char* value) { SetStackId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the stack that's associated with the change set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackName.assign(value); }
|
||||
inline DescribeChangeSetResult& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Information about the change set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline void SetDescription(const Aws::String& value) { m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_description.assign(value); }
|
||||
inline DescribeChangeSetResult& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of <code>Parameter</code> structures that describes the input
|
||||
* parameters and their values used to create the change set. For more information,
|
||||
* see the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html">Parameter</a>
|
||||
* data type.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Parameter>& GetParameters() const{ return m_parameters; }
|
||||
inline void SetParameters(const Aws::Vector<Parameter>& value) { m_parameters = value; }
|
||||
inline void SetParameters(Aws::Vector<Parameter>&& value) { m_parameters = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithParameters(const Aws::Vector<Parameter>& value) { SetParameters(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithParameters(Aws::Vector<Parameter>&& value) { SetParameters(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& AddParameters(const Parameter& value) { m_parameters.push_back(value); return *this; }
|
||||
inline DescribeChangeSetResult& AddParameters(Parameter&& value) { m_parameters.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The start time when the change set was created, in UTC.</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
|
||||
inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTime = value; }
|
||||
inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTime = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If the change set execution status is <code>AVAILABLE</code>, you can execute
|
||||
* the change set. If you can't execute the change set, the status indicates why.
|
||||
* For example, a change set might be in an <code>UNAVAILABLE</code> state because
|
||||
* CloudFormation is still creating it or in an <code>OBSOLETE</code> state because
|
||||
* the stack was already updated.</p>
|
||||
*/
|
||||
inline const ExecutionStatus& GetExecutionStatus() const{ return m_executionStatus; }
|
||||
inline void SetExecutionStatus(const ExecutionStatus& value) { m_executionStatus = value; }
|
||||
inline void SetExecutionStatus(ExecutionStatus&& value) { m_executionStatus = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithExecutionStatus(const ExecutionStatus& value) { SetExecutionStatus(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithExecutionStatus(ExecutionStatus&& value) { SetExecutionStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The current status of the change set, such as
|
||||
* <code>CREATE_IN_PROGRESS</code>, <code>CREATE_COMPLETE</code>, or
|
||||
* <code>FAILED</code>.</p>
|
||||
*/
|
||||
inline const ChangeSetStatus& GetStatus() const{ return m_status; }
|
||||
inline void SetStatus(const ChangeSetStatus& value) { m_status = value; }
|
||||
inline void SetStatus(ChangeSetStatus&& value) { m_status = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithStatus(const ChangeSetStatus& value) { SetStatus(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithStatus(ChangeSetStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A description of the change set's status. For example, if your attempt to
|
||||
* create a change set failed, CloudFormation shows the error message.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStatusReason() const{ return m_statusReason; }
|
||||
inline void SetStatusReason(const Aws::String& value) { m_statusReason = value; }
|
||||
inline void SetStatusReason(Aws::String&& value) { m_statusReason = std::move(value); }
|
||||
inline void SetStatusReason(const char* value) { m_statusReason.assign(value); }
|
||||
inline DescribeChangeSetResult& WithStatusReason(const Aws::String& value) { SetStatusReason(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithStatusReason(Aws::String&& value) { SetStatusReason(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& WithStatusReason(const char* value) { SetStatusReason(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ARNs of the Amazon SNS topics that will be associated with the stack if
|
||||
* you execute the change set.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetNotificationARNs() const{ return m_notificationARNs; }
|
||||
inline void SetNotificationARNs(const Aws::Vector<Aws::String>& value) { m_notificationARNs = value; }
|
||||
inline void SetNotificationARNs(Aws::Vector<Aws::String>&& value) { m_notificationARNs = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithNotificationARNs(const Aws::Vector<Aws::String>& value) { SetNotificationARNs(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithNotificationARNs(Aws::Vector<Aws::String>&& value) { SetNotificationARNs(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& AddNotificationARNs(const Aws::String& value) { m_notificationARNs.push_back(value); return *this; }
|
||||
inline DescribeChangeSetResult& AddNotificationARNs(Aws::String&& value) { m_notificationARNs.push_back(std::move(value)); return *this; }
|
||||
inline DescribeChangeSetResult& AddNotificationARNs(const char* value) { m_notificationARNs.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The rollback triggers for CloudFormation to monitor during stack creation and
|
||||
* updating operations, and for the specified monitoring period afterwards.</p>
|
||||
*/
|
||||
inline const RollbackConfiguration& GetRollbackConfiguration() const{ return m_rollbackConfiguration; }
|
||||
inline void SetRollbackConfiguration(const RollbackConfiguration& value) { m_rollbackConfiguration = value; }
|
||||
inline void SetRollbackConfiguration(RollbackConfiguration&& value) { m_rollbackConfiguration = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithRollbackConfiguration(const RollbackConfiguration& value) { SetRollbackConfiguration(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithRollbackConfiguration(RollbackConfiguration&& value) { SetRollbackConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If you execute the change set, the list of capabilities that were explicitly
|
||||
* acknowledged when the change set was created.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Capability>& GetCapabilities() const{ return m_capabilities; }
|
||||
inline void SetCapabilities(const Aws::Vector<Capability>& value) { m_capabilities = value; }
|
||||
inline void SetCapabilities(Aws::Vector<Capability>&& value) { m_capabilities = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithCapabilities(const Aws::Vector<Capability>& value) { SetCapabilities(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithCapabilities(Aws::Vector<Capability>&& value) { SetCapabilities(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& AddCapabilities(const Capability& value) { m_capabilities.push_back(value); return *this; }
|
||||
inline DescribeChangeSetResult& AddCapabilities(Capability&& value) { m_capabilities.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If you execute the change set, the tags that will be associated with the
|
||||
* stack.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tags = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& AddTags(const Tag& value) { m_tags.push_back(value); return *this; }
|
||||
inline DescribeChangeSetResult& AddTags(Tag&& value) { m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of <code>Change</code> structures that describes the resources
|
||||
* CloudFormation changes if you execute the change set.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Change>& GetChanges() const{ return m_changes; }
|
||||
inline void SetChanges(const Aws::Vector<Change>& value) { m_changes = value; }
|
||||
inline void SetChanges(Aws::Vector<Change>&& value) { m_changes = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithChanges(const Aws::Vector<Change>& value) { SetChanges(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithChanges(Aws::Vector<Change>&& value) { SetChanges(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& AddChanges(const Change& value) { m_changes.push_back(value); return *this; }
|
||||
inline DescribeChangeSetResult& AddChanges(Change&& value) { m_changes.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If the output exceeds 1 MB, a string that identifies the next page of
|
||||
* changes. If there is no additional page, this value is null.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
|
||||
inline DescribeChangeSetResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Verifies if <code>IncludeNestedStacks</code> is set to <code>True</code>.</p>
|
||||
*/
|
||||
inline bool GetIncludeNestedStacks() const{ return m_includeNestedStacks; }
|
||||
inline void SetIncludeNestedStacks(bool value) { m_includeNestedStacks = value; }
|
||||
inline DescribeChangeSetResult& WithIncludeNestedStacks(bool value) { SetIncludeNestedStacks(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Specifies the change set ID of the parent change set in the current nested
|
||||
* change set hierarchy.</p>
|
||||
*/
|
||||
inline const Aws::String& GetParentChangeSetId() const{ return m_parentChangeSetId; }
|
||||
inline void SetParentChangeSetId(const Aws::String& value) { m_parentChangeSetId = value; }
|
||||
inline void SetParentChangeSetId(Aws::String&& value) { m_parentChangeSetId = std::move(value); }
|
||||
inline void SetParentChangeSetId(const char* value) { m_parentChangeSetId.assign(value); }
|
||||
inline DescribeChangeSetResult& WithParentChangeSetId(const Aws::String& value) { SetParentChangeSetId(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithParentChangeSetId(Aws::String&& value) { SetParentChangeSetId(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& WithParentChangeSetId(const char* value) { SetParentChangeSetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Specifies the change set ID of the root change set in the current nested
|
||||
* change set hierarchy.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRootChangeSetId() const{ return m_rootChangeSetId; }
|
||||
inline void SetRootChangeSetId(const Aws::String& value) { m_rootChangeSetId = value; }
|
||||
inline void SetRootChangeSetId(Aws::String&& value) { m_rootChangeSetId = std::move(value); }
|
||||
inline void SetRootChangeSetId(const char* value) { m_rootChangeSetId.assign(value); }
|
||||
inline DescribeChangeSetResult& WithRootChangeSetId(const Aws::String& value) { SetRootChangeSetId(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithRootChangeSetId(Aws::String&& value) { SetRootChangeSetId(std::move(value)); return *this;}
|
||||
inline DescribeChangeSetResult& WithRootChangeSetId(const char* value) { SetRootChangeSetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Determines what action will be taken if stack creation fails. When this
|
||||
* parameter is specified, the <code>DisableRollback</code> parameter to the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html">ExecuteChangeSet</a>
|
||||
* API operation must not be specified. This must be one of these values:</p> <ul>
|
||||
* <li> <p> <code>DELETE</code> - Deletes the change set if the stack creation
|
||||
* fails. This is only valid when the <code>ChangeSetType</code> parameter is set
|
||||
* to <code>CREATE</code>. If the deletion of the stack fails, the status of the
|
||||
* stack is <code>DELETE_FAILED</code>.</p> </li> <li> <p> <code>DO_NOTHING</code>
|
||||
* - if the stack creation fails, do nothing. This is equivalent to specifying
|
||||
* <code>true</code> for the <code>DisableRollback</code> parameter to the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html">ExecuteChangeSet</a>
|
||||
* API operation.</p> </li> <li> <p> <code>ROLLBACK</code> - if the stack creation
|
||||
* fails, roll back the stack. This is equivalent to specifying <code>false</code>
|
||||
* for the <code>DisableRollback</code> parameter to the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html">ExecuteChangeSet</a>
|
||||
* API operation.</p> </li> </ul>
|
||||
*/
|
||||
inline const OnStackFailure& GetOnStackFailure() const{ return m_onStackFailure; }
|
||||
inline void SetOnStackFailure(const OnStackFailure& value) { m_onStackFailure = value; }
|
||||
inline void SetOnStackFailure(OnStackFailure&& value) { m_onStackFailure = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithOnStackFailure(const OnStackFailure& value) { SetOnStackFailure(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithOnStackFailure(OnStackFailure&& value) { SetOnStackFailure(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates if the change set imports resources that already exist.</p>
|
||||
* <p>This parameter can only import resources that have <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html">custom
|
||||
* names</a> in templates. To import resources that do not accept custom names,
|
||||
* such as EC2 instances, use the <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import.html">resource
|
||||
* import</a> feature instead.</p>
|
||||
*/
|
||||
inline bool GetImportExistingResources() const{ return m_importExistingResources; }
|
||||
inline void SetImportExistingResources(bool value) { m_importExistingResources = value; }
|
||||
inline DescribeChangeSetResult& WithImportExistingResources(bool value) { SetImportExistingResources(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeChangeSetResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeChangeSetResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_changeSetName;
|
||||
|
||||
Aws::String m_changeSetId;
|
||||
|
||||
Aws::String m_stackId;
|
||||
|
||||
Aws::String m_stackName;
|
||||
|
||||
Aws::String m_description;
|
||||
|
||||
Aws::Vector<Parameter> m_parameters;
|
||||
|
||||
Aws::Utils::DateTime m_creationTime;
|
||||
|
||||
ExecutionStatus m_executionStatus;
|
||||
|
||||
ChangeSetStatus m_status;
|
||||
|
||||
Aws::String m_statusReason;
|
||||
|
||||
Aws::Vector<Aws::String> m_notificationARNs;
|
||||
|
||||
RollbackConfiguration m_rollbackConfiguration;
|
||||
|
||||
Aws::Vector<Capability> m_capabilities;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
|
||||
Aws::Vector<Change> m_changes;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
|
||||
bool m_includeNestedStacks;
|
||||
|
||||
Aws::String m_parentChangeSetId;
|
||||
|
||||
Aws::String m_rootChangeSetId;
|
||||
|
||||
OnStackFailure m_onStackFailure;
|
||||
|
||||
bool m_importExistingResources;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribeGeneratedTemplateRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeGeneratedTemplateRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeGeneratedTemplate"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or Amazon Resource Name (ARN) of a generated template.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGeneratedTemplateName() const{ return m_generatedTemplateName; }
|
||||
inline bool GeneratedTemplateNameHasBeenSet() const { return m_generatedTemplateNameHasBeenSet; }
|
||||
inline void SetGeneratedTemplateName(const Aws::String& value) { m_generatedTemplateNameHasBeenSet = true; m_generatedTemplateName = value; }
|
||||
inline void SetGeneratedTemplateName(Aws::String&& value) { m_generatedTemplateNameHasBeenSet = true; m_generatedTemplateName = std::move(value); }
|
||||
inline void SetGeneratedTemplateName(const char* value) { m_generatedTemplateNameHasBeenSet = true; m_generatedTemplateName.assign(value); }
|
||||
inline DescribeGeneratedTemplateRequest& WithGeneratedTemplateName(const Aws::String& value) { SetGeneratedTemplateName(value); return *this;}
|
||||
inline DescribeGeneratedTemplateRequest& WithGeneratedTemplateName(Aws::String&& value) { SetGeneratedTemplateName(std::move(value)); return *this;}
|
||||
inline DescribeGeneratedTemplateRequest& WithGeneratedTemplateName(const char* value) { SetGeneratedTemplateName(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_generatedTemplateName;
|
||||
bool m_generatedTemplateNameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,227 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/GeneratedTemplateStatus.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <aws/cloudformation/model/TemplateProgress.h>
|
||||
#include <aws/cloudformation/model/TemplateConfiguration.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <aws/cloudformation/model/ResourceDetail.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribeGeneratedTemplateResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeGeneratedTemplateResult();
|
||||
AWS_CLOUDFORMATION_API DescribeGeneratedTemplateResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeGeneratedTemplateResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the generated template. The format is
|
||||
* <code>arn:${Partition}:cloudformation:${Region}:${Account}:generatedtemplate/${Id}</code>.
|
||||
* For example,
|
||||
* <code>arn:aws:cloudformation:<i>us-east-1</i>:<i>123456789012</i>:generatedtemplate/<i>2e8465c1-9a80-43ea-a3a3-4f2d692fe6dc</i>
|
||||
* </code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGeneratedTemplateId() const{ return m_generatedTemplateId; }
|
||||
inline void SetGeneratedTemplateId(const Aws::String& value) { m_generatedTemplateId = value; }
|
||||
inline void SetGeneratedTemplateId(Aws::String&& value) { m_generatedTemplateId = std::move(value); }
|
||||
inline void SetGeneratedTemplateId(const char* value) { m_generatedTemplateId.assign(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithGeneratedTemplateId(const Aws::String& value) { SetGeneratedTemplateId(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithGeneratedTemplateId(Aws::String&& value) { SetGeneratedTemplateId(std::move(value)); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithGeneratedTemplateId(const char* value) { SetGeneratedTemplateId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the generated template.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGeneratedTemplateName() const{ return m_generatedTemplateName; }
|
||||
inline void SetGeneratedTemplateName(const Aws::String& value) { m_generatedTemplateName = value; }
|
||||
inline void SetGeneratedTemplateName(Aws::String&& value) { m_generatedTemplateName = std::move(value); }
|
||||
inline void SetGeneratedTemplateName(const char* value) { m_generatedTemplateName.assign(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithGeneratedTemplateName(const Aws::String& value) { SetGeneratedTemplateName(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithGeneratedTemplateName(Aws::String&& value) { SetGeneratedTemplateName(std::move(value)); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithGeneratedTemplateName(const char* value) { SetGeneratedTemplateName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of objects describing the details of the resources in the template
|
||||
* generation.</p>
|
||||
*/
|
||||
inline const Aws::Vector<ResourceDetail>& GetResources() const{ return m_resources; }
|
||||
inline void SetResources(const Aws::Vector<ResourceDetail>& value) { m_resources = value; }
|
||||
inline void SetResources(Aws::Vector<ResourceDetail>&& value) { m_resources = std::move(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithResources(const Aws::Vector<ResourceDetail>& value) { SetResources(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithResources(Aws::Vector<ResourceDetail>&& value) { SetResources(std::move(value)); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& AddResources(const ResourceDetail& value) { m_resources.push_back(value); return *this; }
|
||||
inline DescribeGeneratedTemplateResult& AddResources(ResourceDetail&& value) { m_resources.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The status of the template generation. Supported values are:</p> <ul> <li>
|
||||
* <p> <code>CreatePending</code> - the creation of the template is pending.</p>
|
||||
* </li> <li> <p> <code>CreateInProgress</code> - the creation of the template is
|
||||
* in progress.</p> </li> <li> <p> <code>DeletePending</code> - the deletion of the
|
||||
* template is pending.</p> </li> <li> <p> <code>DeleteInProgress</code> - the
|
||||
* deletion of the template is in progress.</p> </li> <li> <p>
|
||||
* <code>UpdatePending</code> - the update of the template is pending.</p> </li>
|
||||
* <li> <p> <code>UpdateInProgress</code> - the update of the template is in
|
||||
* progress.</p> </li> <li> <p> <code>Failed</code> - the template operation
|
||||
* failed.</p> </li> <li> <p> <code>Complete</code> - the template operation is
|
||||
* complete.</p> </li> </ul>
|
||||
*/
|
||||
inline const GeneratedTemplateStatus& GetStatus() const{ return m_status; }
|
||||
inline void SetStatus(const GeneratedTemplateStatus& value) { m_status = value; }
|
||||
inline void SetStatus(GeneratedTemplateStatus&& value) { m_status = std::move(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithStatus(const GeneratedTemplateStatus& value) { SetStatus(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithStatus(GeneratedTemplateStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The reason for the current template generation status. This will provide more
|
||||
* details if a failure happened.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStatusReason() const{ return m_statusReason; }
|
||||
inline void SetStatusReason(const Aws::String& value) { m_statusReason = value; }
|
||||
inline void SetStatusReason(Aws::String&& value) { m_statusReason = std::move(value); }
|
||||
inline void SetStatusReason(const char* value) { m_statusReason.assign(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithStatusReason(const Aws::String& value) { SetStatusReason(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithStatusReason(Aws::String&& value) { SetStatusReason(std::move(value)); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithStatusReason(const char* value) { SetStatusReason(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The time the generated template was created.</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
|
||||
inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTime = value; }
|
||||
inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTime = std::move(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The time the generated template was last updated.</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetLastUpdatedTime() const{ return m_lastUpdatedTime; }
|
||||
inline void SetLastUpdatedTime(const Aws::Utils::DateTime& value) { m_lastUpdatedTime = value; }
|
||||
inline void SetLastUpdatedTime(Aws::Utils::DateTime&& value) { m_lastUpdatedTime = std::move(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithLastUpdatedTime(const Aws::Utils::DateTime& value) { SetLastUpdatedTime(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithLastUpdatedTime(Aws::Utils::DateTime&& value) { SetLastUpdatedTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An object describing the progress of the template generation.</p>
|
||||
*/
|
||||
inline const TemplateProgress& GetProgress() const{ return m_progress; }
|
||||
inline void SetProgress(const TemplateProgress& value) { m_progress = value; }
|
||||
inline void SetProgress(TemplateProgress&& value) { m_progress = std::move(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithProgress(const TemplateProgress& value) { SetProgress(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithProgress(TemplateProgress&& value) { SetProgress(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The stack ARN of the base stack if a base stack was provided when generating
|
||||
* the template.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackId() const{ return m_stackId; }
|
||||
inline void SetStackId(const Aws::String& value) { m_stackId = value; }
|
||||
inline void SetStackId(Aws::String&& value) { m_stackId = std::move(value); }
|
||||
inline void SetStackId(const char* value) { m_stackId.assign(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithStackId(const Aws::String& value) { SetStackId(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithStackId(Aws::String&& value) { SetStackId(std::move(value)); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithStackId(const char* value) { SetStackId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The configuration details of the generated template, including the
|
||||
* <code>DeletionPolicy</code> and <code>UpdateReplacePolicy</code>.</p>
|
||||
*/
|
||||
inline const TemplateConfiguration& GetTemplateConfiguration() const{ return m_templateConfiguration; }
|
||||
inline void SetTemplateConfiguration(const TemplateConfiguration& value) { m_templateConfiguration = value; }
|
||||
inline void SetTemplateConfiguration(TemplateConfiguration&& value) { m_templateConfiguration = std::move(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithTemplateConfiguration(const TemplateConfiguration& value) { SetTemplateConfiguration(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithTemplateConfiguration(TemplateConfiguration&& value) { SetTemplateConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The number of warnings generated for this template. The warnings are found in
|
||||
* the details of each of the resources in the template.</p>
|
||||
*/
|
||||
inline int GetTotalWarnings() const{ return m_totalWarnings; }
|
||||
inline void SetTotalWarnings(int value) { m_totalWarnings = value; }
|
||||
inline DescribeGeneratedTemplateResult& WithTotalWarnings(int value) { SetTotalWarnings(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeGeneratedTemplateResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeGeneratedTemplateResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_generatedTemplateId;
|
||||
|
||||
Aws::String m_generatedTemplateName;
|
||||
|
||||
Aws::Vector<ResourceDetail> m_resources;
|
||||
|
||||
GeneratedTemplateStatus m_status;
|
||||
|
||||
Aws::String m_statusReason;
|
||||
|
||||
Aws::Utils::DateTime m_creationTime;
|
||||
|
||||
Aws::Utils::DateTime m_lastUpdatedTime;
|
||||
|
||||
TemplateProgress m_progress;
|
||||
|
||||
Aws::String m_stackId;
|
||||
|
||||
TemplateConfiguration m_templateConfiguration;
|
||||
|
||||
int m_totalWarnings;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,68 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/cloudformation/model/CallAs.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribeOrganizationsAccessRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeOrganizationsAccessRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeOrganizationsAccess"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Service-managed permissions] Specifies whether you are acting as an account
|
||||
* administrator in the organization's management account or as a delegated
|
||||
* administrator in a member account.</p> <p>By default, <code>SELF</code> is
|
||||
* specified.</p> <ul> <li> <p>If you are signed in to the management account,
|
||||
* specify <code>SELF</code>.</p> </li> <li> <p>If you are signed in to a delegated
|
||||
* administrator account, specify <code>DELEGATED_ADMIN</code>.</p> <p>Your Amazon
|
||||
* Web Services account must be registered as a delegated administrator in the
|
||||
* management account. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html">Register
|
||||
* a delegated administrator</a> in the <i>CloudFormation User Guide</i>.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const CallAs& GetCallAs() const{ return m_callAs; }
|
||||
inline bool CallAsHasBeenSet() const { return m_callAsHasBeenSet; }
|
||||
inline void SetCallAs(const CallAs& value) { m_callAsHasBeenSet = true; m_callAs = value; }
|
||||
inline void SetCallAs(CallAs&& value) { m_callAsHasBeenSet = true; m_callAs = std::move(value); }
|
||||
inline DescribeOrganizationsAccessRequest& WithCallAs(const CallAs& value) { SetCallAs(value); return *this;}
|
||||
inline DescribeOrganizationsAccessRequest& WithCallAs(CallAs&& value) { SetCallAs(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
CallAs m_callAs;
|
||||
bool m_callAsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,64 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/OrganizationStatus.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribeOrganizationsAccessResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeOrganizationsAccessResult();
|
||||
AWS_CLOUDFORMATION_API DescribeOrganizationsAccessResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeOrganizationsAccessResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Presents the status of the <code>OrganizationAccess</code>.</p>
|
||||
*/
|
||||
inline const OrganizationStatus& GetStatus() const{ return m_status; }
|
||||
inline void SetStatus(const OrganizationStatus& value) { m_status = value; }
|
||||
inline void SetStatus(OrganizationStatus&& value) { m_status = std::move(value); }
|
||||
inline DescribeOrganizationsAccessResult& WithStatus(const OrganizationStatus& value) { SetStatus(value); return *this;}
|
||||
inline DescribeOrganizationsAccessResult& WithStatus(OrganizationStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeOrganizationsAccessResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeOrganizationsAccessResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
OrganizationStatus m_status;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,63 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribePublisherRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribePublisherRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribePublisher"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the extension publisher.</p> <p>If you don't supply a
|
||||
* <code>PublisherId</code>, and you have registered as an extension publisher,
|
||||
* <code>DescribePublisher</code> returns information about your own publisher
|
||||
* account.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPublisherId() const{ return m_publisherId; }
|
||||
inline bool PublisherIdHasBeenSet() const { return m_publisherIdHasBeenSet; }
|
||||
inline void SetPublisherId(const Aws::String& value) { m_publisherIdHasBeenSet = true; m_publisherId = value; }
|
||||
inline void SetPublisherId(Aws::String&& value) { m_publisherIdHasBeenSet = true; m_publisherId = std::move(value); }
|
||||
inline void SetPublisherId(const char* value) { m_publisherIdHasBeenSet = true; m_publisherId.assign(value); }
|
||||
inline DescribePublisherRequest& WithPublisherId(const Aws::String& value) { SetPublisherId(value); return *this;}
|
||||
inline DescribePublisherRequest& WithPublisherId(Aws::String&& value) { SetPublisherId(std::move(value)); return *this;}
|
||||
inline DescribePublisherRequest& WithPublisherId(const char* value) { SetPublisherId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_publisherId;
|
||||
bool m_publisherIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,111 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/PublisherStatus.h>
|
||||
#include <aws/cloudformation/model/IdentityProvider.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribePublisherResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribePublisherResult();
|
||||
AWS_CLOUDFORMATION_API DescribePublisherResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribePublisherResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the extension publisher.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPublisherId() const{ return m_publisherId; }
|
||||
inline void SetPublisherId(const Aws::String& value) { m_publisherId = value; }
|
||||
inline void SetPublisherId(Aws::String&& value) { m_publisherId = std::move(value); }
|
||||
inline void SetPublisherId(const char* value) { m_publisherId.assign(value); }
|
||||
inline DescribePublisherResult& WithPublisherId(const Aws::String& value) { SetPublisherId(value); return *this;}
|
||||
inline DescribePublisherResult& WithPublisherId(Aws::String&& value) { SetPublisherId(std::move(value)); return *this;}
|
||||
inline DescribePublisherResult& WithPublisherId(const char* value) { SetPublisherId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Whether the publisher is verified. Currently, all registered publishers are
|
||||
* verified.</p>
|
||||
*/
|
||||
inline const PublisherStatus& GetPublisherStatus() const{ return m_publisherStatus; }
|
||||
inline void SetPublisherStatus(const PublisherStatus& value) { m_publisherStatus = value; }
|
||||
inline void SetPublisherStatus(PublisherStatus&& value) { m_publisherStatus = std::move(value); }
|
||||
inline DescribePublisherResult& WithPublisherStatus(const PublisherStatus& value) { SetPublisherStatus(value); return *this;}
|
||||
inline DescribePublisherResult& WithPublisherStatus(PublisherStatus&& value) { SetPublisherStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type of account used as the identity provider when registering this
|
||||
* publisher with CloudFormation.</p>
|
||||
*/
|
||||
inline const IdentityProvider& GetIdentityProvider() const{ return m_identityProvider; }
|
||||
inline void SetIdentityProvider(const IdentityProvider& value) { m_identityProvider = value; }
|
||||
inline void SetIdentityProvider(IdentityProvider&& value) { m_identityProvider = std::move(value); }
|
||||
inline DescribePublisherResult& WithIdentityProvider(const IdentityProvider& value) { SetIdentityProvider(value); return *this;}
|
||||
inline DescribePublisherResult& WithIdentityProvider(IdentityProvider&& value) { SetIdentityProvider(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The URL to the publisher's profile with the identity provider.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPublisherProfile() const{ return m_publisherProfile; }
|
||||
inline void SetPublisherProfile(const Aws::String& value) { m_publisherProfile = value; }
|
||||
inline void SetPublisherProfile(Aws::String&& value) { m_publisherProfile = std::move(value); }
|
||||
inline void SetPublisherProfile(const char* value) { m_publisherProfile.assign(value); }
|
||||
inline DescribePublisherResult& WithPublisherProfile(const Aws::String& value) { SetPublisherProfile(value); return *this;}
|
||||
inline DescribePublisherResult& WithPublisherProfile(Aws::String&& value) { SetPublisherProfile(std::move(value)); return *this;}
|
||||
inline DescribePublisherResult& WithPublisherProfile(const char* value) { SetPublisherProfile(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribePublisherResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribePublisherResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_publisherId;
|
||||
|
||||
PublisherStatus m_publisherStatus;
|
||||
|
||||
IdentityProvider m_identityProvider;
|
||||
|
||||
Aws::String m_publisherProfile;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribeResourceScanRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeResourceScanRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeResourceScan"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the resource scan.</p>
|
||||
*/
|
||||
inline const Aws::String& GetResourceScanId() const{ return m_resourceScanId; }
|
||||
inline bool ResourceScanIdHasBeenSet() const { return m_resourceScanIdHasBeenSet; }
|
||||
inline void SetResourceScanId(const Aws::String& value) { m_resourceScanIdHasBeenSet = true; m_resourceScanId = value; }
|
||||
inline void SetResourceScanId(Aws::String&& value) { m_resourceScanIdHasBeenSet = true; m_resourceScanId = std::move(value); }
|
||||
inline void SetResourceScanId(const char* value) { m_resourceScanIdHasBeenSet = true; m_resourceScanId.assign(value); }
|
||||
inline DescribeResourceScanRequest& WithResourceScanId(const Aws::String& value) { SetResourceScanId(value); return *this;}
|
||||
inline DescribeResourceScanRequest& WithResourceScanId(Aws::String&& value) { SetResourceScanId(std::move(value)); return *this;}
|
||||
inline DescribeResourceScanRequest& WithResourceScanId(const char* value) { SetResourceScanId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_resourceScanId;
|
||||
bool m_resourceScanIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,188 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResourceScanStatus.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribeResourceScanResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeResourceScanResult();
|
||||
AWS_CLOUDFORMATION_API DescribeResourceScanResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeResourceScanResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the resource scan. The format is
|
||||
* <code>arn:${Partition}:cloudformation:${Region}:${Account}:resourceScan/${Id}</code>.
|
||||
* An example is
|
||||
* <code>arn:aws:cloudformation:<i>us-east-1</i>:<i>123456789012</i>:resourceScan/<i>f5b490f7-7ed4-428a-aa06-31ff25db0772</i>
|
||||
* </code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetResourceScanId() const{ return m_resourceScanId; }
|
||||
inline void SetResourceScanId(const Aws::String& value) { m_resourceScanId = value; }
|
||||
inline void SetResourceScanId(Aws::String&& value) { m_resourceScanId = std::move(value); }
|
||||
inline void SetResourceScanId(const char* value) { m_resourceScanId.assign(value); }
|
||||
inline DescribeResourceScanResult& WithResourceScanId(const Aws::String& value) { SetResourceScanId(value); return *this;}
|
||||
inline DescribeResourceScanResult& WithResourceScanId(Aws::String&& value) { SetResourceScanId(std::move(value)); return *this;}
|
||||
inline DescribeResourceScanResult& WithResourceScanId(const char* value) { SetResourceScanId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Status of the resource scan.</p> <dl> <dt> INPROGRESS </dt> <dd> <p>The
|
||||
* resource scan is still in progress.</p> </dd> <dt> COMPLETE </dt> <dd> <p>The
|
||||
* resource scan is complete.</p> </dd> <dt> EXPIRED </dt> <dd> <p>The resource
|
||||
* scan has expired.</p> </dd> <dt> FAILED </dt> <dd> <p>The resource scan has
|
||||
* failed.</p> </dd> </dl>
|
||||
*/
|
||||
inline const ResourceScanStatus& GetStatus() const{ return m_status; }
|
||||
inline void SetStatus(const ResourceScanStatus& value) { m_status = value; }
|
||||
inline void SetStatus(ResourceScanStatus&& value) { m_status = std::move(value); }
|
||||
inline DescribeResourceScanResult& WithStatus(const ResourceScanStatus& value) { SetStatus(value); return *this;}
|
||||
inline DescribeResourceScanResult& WithStatus(ResourceScanStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The reason for the resource scan status, providing more information if a
|
||||
* failure happened.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStatusReason() const{ return m_statusReason; }
|
||||
inline void SetStatusReason(const Aws::String& value) { m_statusReason = value; }
|
||||
inline void SetStatusReason(Aws::String&& value) { m_statusReason = std::move(value); }
|
||||
inline void SetStatusReason(const char* value) { m_statusReason.assign(value); }
|
||||
inline DescribeResourceScanResult& WithStatusReason(const Aws::String& value) { SetStatusReason(value); return *this;}
|
||||
inline DescribeResourceScanResult& WithStatusReason(Aws::String&& value) { SetStatusReason(std::move(value)); return *this;}
|
||||
inline DescribeResourceScanResult& WithStatusReason(const char* value) { SetStatusReason(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The time that the resource scan was started.</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetStartTime() const{ return m_startTime; }
|
||||
inline void SetStartTime(const Aws::Utils::DateTime& value) { m_startTime = value; }
|
||||
inline void SetStartTime(Aws::Utils::DateTime&& value) { m_startTime = std::move(value); }
|
||||
inline DescribeResourceScanResult& WithStartTime(const Aws::Utils::DateTime& value) { SetStartTime(value); return *this;}
|
||||
inline DescribeResourceScanResult& WithStartTime(Aws::Utils::DateTime&& value) { SetStartTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The time that the resource scan was finished.</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetEndTime() const{ return m_endTime; }
|
||||
inline void SetEndTime(const Aws::Utils::DateTime& value) { m_endTime = value; }
|
||||
inline void SetEndTime(Aws::Utils::DateTime&& value) { m_endTime = std::move(value); }
|
||||
inline DescribeResourceScanResult& WithEndTime(const Aws::Utils::DateTime& value) { SetEndTime(value); return *this;}
|
||||
inline DescribeResourceScanResult& WithEndTime(Aws::Utils::DateTime&& value) { SetEndTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The percentage of the resource scan that has been completed.</p>
|
||||
*/
|
||||
inline double GetPercentageCompleted() const{ return m_percentageCompleted; }
|
||||
inline void SetPercentageCompleted(double value) { m_percentageCompleted = value; }
|
||||
inline DescribeResourceScanResult& WithPercentageCompleted(double value) { SetPercentageCompleted(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The list of resource types for the specified scan. Resource types are only
|
||||
* available for scans with a <code>Status</code> set to <code>COMPLETE</code> or
|
||||
* <code>FAILED </code>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetResourceTypes() const{ return m_resourceTypes; }
|
||||
inline void SetResourceTypes(const Aws::Vector<Aws::String>& value) { m_resourceTypes = value; }
|
||||
inline void SetResourceTypes(Aws::Vector<Aws::String>&& value) { m_resourceTypes = std::move(value); }
|
||||
inline DescribeResourceScanResult& WithResourceTypes(const Aws::Vector<Aws::String>& value) { SetResourceTypes(value); return *this;}
|
||||
inline DescribeResourceScanResult& WithResourceTypes(Aws::Vector<Aws::String>&& value) { SetResourceTypes(std::move(value)); return *this;}
|
||||
inline DescribeResourceScanResult& AddResourceTypes(const Aws::String& value) { m_resourceTypes.push_back(value); return *this; }
|
||||
inline DescribeResourceScanResult& AddResourceTypes(Aws::String&& value) { m_resourceTypes.push_back(std::move(value)); return *this; }
|
||||
inline DescribeResourceScanResult& AddResourceTypes(const char* value) { m_resourceTypes.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The number of resources that were listed. This is only available for scans
|
||||
* with a <code>Status</code> set to <code>COMPLETE</code>, <code>EXPIRED</code>,
|
||||
* or <code>FAILED </code>.</p>
|
||||
*/
|
||||
inline int GetResourcesScanned() const{ return m_resourcesScanned; }
|
||||
inline void SetResourcesScanned(int value) { m_resourcesScanned = value; }
|
||||
inline DescribeResourceScanResult& WithResourcesScanned(int value) { SetResourcesScanned(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The number of resources that were read. This is only available for scans with
|
||||
* a <code>Status</code> set to <code>COMPLETE</code>, <code>EXPIRED</code>, or
|
||||
* <code>FAILED </code>.</p> <p>This field may be 0 if the resource scan
|
||||
* failed with a <code>ResourceScanLimitExceededException</code>.</p>
|
||||
*/
|
||||
inline int GetResourcesRead() const{ return m_resourcesRead; }
|
||||
inline void SetResourcesRead(int value) { m_resourcesRead = value; }
|
||||
inline DescribeResourceScanResult& WithResourcesRead(int value) { SetResourcesRead(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeResourceScanResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeResourceScanResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_resourceScanId;
|
||||
|
||||
ResourceScanStatus m_status;
|
||||
|
||||
Aws::String m_statusReason;
|
||||
|
||||
Aws::Utils::DateTime m_startTime;
|
||||
|
||||
Aws::Utils::DateTime m_endTime;
|
||||
|
||||
double m_percentageCompleted;
|
||||
|
||||
Aws::Vector<Aws::String> m_resourceTypes;
|
||||
|
||||
int m_resourcesScanned;
|
||||
|
||||
int m_resourcesRead;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,63 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribeStackDriftDetectionStatusRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackDriftDetectionStatusRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeStackDriftDetectionStatus"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the drift detection results of this operation.</p>
|
||||
* <p>CloudFormation generates new results, with a new drift detection ID, each
|
||||
* time this operation is run. However, the number of drift results CloudFormation
|
||||
* retains for any given stack, and for how long, may vary.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackDriftDetectionId() const{ return m_stackDriftDetectionId; }
|
||||
inline bool StackDriftDetectionIdHasBeenSet() const { return m_stackDriftDetectionIdHasBeenSet; }
|
||||
inline void SetStackDriftDetectionId(const Aws::String& value) { m_stackDriftDetectionIdHasBeenSet = true; m_stackDriftDetectionId = value; }
|
||||
inline void SetStackDriftDetectionId(Aws::String&& value) { m_stackDriftDetectionIdHasBeenSet = true; m_stackDriftDetectionId = std::move(value); }
|
||||
inline void SetStackDriftDetectionId(const char* value) { m_stackDriftDetectionIdHasBeenSet = true; m_stackDriftDetectionId.assign(value); }
|
||||
inline DescribeStackDriftDetectionStatusRequest& WithStackDriftDetectionId(const Aws::String& value) { SetStackDriftDetectionId(value); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusRequest& WithStackDriftDetectionId(Aws::String&& value) { SetStackDriftDetectionId(std::move(value)); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusRequest& WithStackDriftDetectionId(const char* value) { SetStackDriftDetectionId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackDriftDetectionId;
|
||||
bool m_stackDriftDetectionIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,173 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/StackDriftStatus.h>
|
||||
#include <aws/cloudformation/model/StackDriftDetectionStatus.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribeStackDriftDetectionStatusResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackDriftDetectionStatusResult();
|
||||
AWS_CLOUDFORMATION_API DescribeStackDriftDetectionStatusResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeStackDriftDetectionStatusResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the stack.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackId() const{ return m_stackId; }
|
||||
inline void SetStackId(const Aws::String& value) { m_stackId = value; }
|
||||
inline void SetStackId(Aws::String&& value) { m_stackId = std::move(value); }
|
||||
inline void SetStackId(const char* value) { m_stackId.assign(value); }
|
||||
inline DescribeStackDriftDetectionStatusResult& WithStackId(const Aws::String& value) { SetStackId(value); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusResult& WithStackId(Aws::String&& value) { SetStackId(std::move(value)); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusResult& WithStackId(const char* value) { SetStackId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the drift detection results of this operation.</p>
|
||||
* <p>CloudFormation generates new results, with a new drift detection ID, each
|
||||
* time this operation is run. However, the number of reports CloudFormation
|
||||
* retains for any given stack, and for how long, may vary.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackDriftDetectionId() const{ return m_stackDriftDetectionId; }
|
||||
inline void SetStackDriftDetectionId(const Aws::String& value) { m_stackDriftDetectionId = value; }
|
||||
inline void SetStackDriftDetectionId(Aws::String&& value) { m_stackDriftDetectionId = std::move(value); }
|
||||
inline void SetStackDriftDetectionId(const char* value) { m_stackDriftDetectionId.assign(value); }
|
||||
inline DescribeStackDriftDetectionStatusResult& WithStackDriftDetectionId(const Aws::String& value) { SetStackDriftDetectionId(value); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusResult& WithStackDriftDetectionId(Aws::String&& value) { SetStackDriftDetectionId(std::move(value)); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusResult& WithStackDriftDetectionId(const char* value) { SetStackDriftDetectionId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Status of the stack's actual configuration compared to its expected
|
||||
* configuration.</p> <ul> <li> <p> <code>DRIFTED</code>: The stack differs from
|
||||
* its expected template configuration. A stack is considered to have drifted if
|
||||
* one or more of its resources have drifted.</p> </li> <li> <p>
|
||||
* <code>NOT_CHECKED</code>: CloudFormation hasn't checked if the stack differs
|
||||
* from its expected template configuration.</p> </li> <li> <p>
|
||||
* <code>IN_SYNC</code>: The stack's actual configuration matches its expected
|
||||
* template configuration.</p> </li> <li> <p> <code>UNKNOWN</code>: This value is
|
||||
* reserved for future use.</p> </li> </ul>
|
||||
*/
|
||||
inline const StackDriftStatus& GetStackDriftStatus() const{ return m_stackDriftStatus; }
|
||||
inline void SetStackDriftStatus(const StackDriftStatus& value) { m_stackDriftStatus = value; }
|
||||
inline void SetStackDriftStatus(StackDriftStatus&& value) { m_stackDriftStatus = std::move(value); }
|
||||
inline DescribeStackDriftDetectionStatusResult& WithStackDriftStatus(const StackDriftStatus& value) { SetStackDriftStatus(value); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusResult& WithStackDriftStatus(StackDriftStatus&& value) { SetStackDriftStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The status of the stack drift detection operation.</p> <ul> <li> <p>
|
||||
* <code>DETECTION_COMPLETE</code>: The stack drift detection operation has
|
||||
* successfully completed for all resources in the stack that support drift
|
||||
* detection. (Resources that don't currently support stack detection remain
|
||||
* unchecked.)</p> <p>If you specified logical resource IDs for CloudFormation to
|
||||
* use as a filter for the stack drift detection operation, only the resources with
|
||||
* those logical IDs are checked for drift.</p> </li> <li> <p>
|
||||
* <code>DETECTION_FAILED</code>: The stack drift detection operation has failed
|
||||
* for at least one resource in the stack. Results will be available for resources
|
||||
* on which CloudFormation successfully completed drift detection.</p> </li> <li>
|
||||
* <p> <code>DETECTION_IN_PROGRESS</code>: The stack drift detection operation is
|
||||
* currently in progress.</p> </li> </ul>
|
||||
*/
|
||||
inline const StackDriftDetectionStatus& GetDetectionStatus() const{ return m_detectionStatus; }
|
||||
inline void SetDetectionStatus(const StackDriftDetectionStatus& value) { m_detectionStatus = value; }
|
||||
inline void SetDetectionStatus(StackDriftDetectionStatus&& value) { m_detectionStatus = std::move(value); }
|
||||
inline DescribeStackDriftDetectionStatusResult& WithDetectionStatus(const StackDriftDetectionStatus& value) { SetDetectionStatus(value); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusResult& WithDetectionStatus(StackDriftDetectionStatus&& value) { SetDetectionStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The reason the stack drift detection operation has its current status.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDetectionStatusReason() const{ return m_detectionStatusReason; }
|
||||
inline void SetDetectionStatusReason(const Aws::String& value) { m_detectionStatusReason = value; }
|
||||
inline void SetDetectionStatusReason(Aws::String&& value) { m_detectionStatusReason = std::move(value); }
|
||||
inline void SetDetectionStatusReason(const char* value) { m_detectionStatusReason.assign(value); }
|
||||
inline DescribeStackDriftDetectionStatusResult& WithDetectionStatusReason(const Aws::String& value) { SetDetectionStatusReason(value); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusResult& WithDetectionStatusReason(Aws::String&& value) { SetDetectionStatusReason(std::move(value)); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusResult& WithDetectionStatusReason(const char* value) { SetDetectionStatusReason(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Total number of stack resources that have drifted. This is NULL until the
|
||||
* drift detection operation reaches a status of <code>DETECTION_COMPLETE</code>.
|
||||
* This value will be 0 for stacks whose drift status is <code>IN_SYNC</code>.</p>
|
||||
*/
|
||||
inline int GetDriftedStackResourceCount() const{ return m_driftedStackResourceCount; }
|
||||
inline void SetDriftedStackResourceCount(int value) { m_driftedStackResourceCount = value; }
|
||||
inline DescribeStackDriftDetectionStatusResult& WithDriftedStackResourceCount(int value) { SetDriftedStackResourceCount(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Time at which the stack drift detection operation was initiated.</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetTimestamp() const{ return m_timestamp; }
|
||||
inline void SetTimestamp(const Aws::Utils::DateTime& value) { m_timestamp = value; }
|
||||
inline void SetTimestamp(Aws::Utils::DateTime&& value) { m_timestamp = std::move(value); }
|
||||
inline DescribeStackDriftDetectionStatusResult& WithTimestamp(const Aws::Utils::DateTime& value) { SetTimestamp(value); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusResult& WithTimestamp(Aws::Utils::DateTime&& value) { SetTimestamp(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeStackDriftDetectionStatusResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeStackDriftDetectionStatusResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackId;
|
||||
|
||||
Aws::String m_stackDriftDetectionId;
|
||||
|
||||
StackDriftStatus m_stackDriftStatus;
|
||||
|
||||
StackDriftDetectionStatus m_detectionStatus;
|
||||
|
||||
Aws::String m_detectionStatusReason;
|
||||
|
||||
int m_driftedStackResourceCount;
|
||||
|
||||
Aws::Utils::DateTime m_timestamp;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,86 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for <a>DescribeStackEvents</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeStackEventsInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeStackEventsRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackEventsRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeStackEvents"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or the unique stack ID that's associated with the stack, which
|
||||
* aren't always interchangeable:</p> <ul> <li> <p>Running stacks: You can specify
|
||||
* either the stack's name or its unique stack ID.</p> </li> <li> <p>Deleted
|
||||
* stacks: You must specify the unique stack ID.</p> </li> </ul> <p>Default: There
|
||||
* is no default value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline DescribeStackEventsRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DescribeStackEventsRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DescribeStackEventsRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A string that identifies the next page of events that you want to
|
||||
* retrieve.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
|
||||
inline DescribeStackEventsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeStackEventsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeStackEventsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
bool m_nextTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,90 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <aws/cloudformation/model/StackEvent.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The output for a <a>DescribeStackEvents</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeStackEventsOutput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeStackEventsResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackEventsResult();
|
||||
AWS_CLOUDFORMATION_API DescribeStackEventsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeStackEventsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of <code>StackEvents</code> structures.</p>
|
||||
*/
|
||||
inline const Aws::Vector<StackEvent>& GetStackEvents() const{ return m_stackEvents; }
|
||||
inline void SetStackEvents(const Aws::Vector<StackEvent>& value) { m_stackEvents = value; }
|
||||
inline void SetStackEvents(Aws::Vector<StackEvent>&& value) { m_stackEvents = std::move(value); }
|
||||
inline DescribeStackEventsResult& WithStackEvents(const Aws::Vector<StackEvent>& value) { SetStackEvents(value); return *this;}
|
||||
inline DescribeStackEventsResult& WithStackEvents(Aws::Vector<StackEvent>&& value) { SetStackEvents(std::move(value)); return *this;}
|
||||
inline DescribeStackEventsResult& AddStackEvents(const StackEvent& value) { m_stackEvents.push_back(value); return *this; }
|
||||
inline DescribeStackEventsResult& AddStackEvents(StackEvent&& value) { m_stackEvents.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If the output exceeds 1 MB in size, a string that identifies the next page of
|
||||
* events. If no additional page exists, this value is null.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
|
||||
inline DescribeStackEventsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeStackEventsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeStackEventsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeStackEventsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeStackEventsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<StackEvent> m_stackEvents;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,123 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/CallAs.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribeStackInstanceRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackInstanceRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeStackInstance"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or the unique stack ID of the stack set that you want to get stack
|
||||
* instance information for.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackSetName() const{ return m_stackSetName; }
|
||||
inline bool StackSetNameHasBeenSet() const { return m_stackSetNameHasBeenSet; }
|
||||
inline void SetStackSetName(const Aws::String& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = value; }
|
||||
inline void SetStackSetName(Aws::String&& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = std::move(value); }
|
||||
inline void SetStackSetName(const char* value) { m_stackSetNameHasBeenSet = true; m_stackSetName.assign(value); }
|
||||
inline DescribeStackInstanceRequest& WithStackSetName(const Aws::String& value) { SetStackSetName(value); return *this;}
|
||||
inline DescribeStackInstanceRequest& WithStackSetName(Aws::String&& value) { SetStackSetName(std::move(value)); return *this;}
|
||||
inline DescribeStackInstanceRequest& WithStackSetName(const char* value) { SetStackSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of an Amazon Web Services account that's associated with this stack
|
||||
* instance.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackInstanceAccount() const{ return m_stackInstanceAccount; }
|
||||
inline bool StackInstanceAccountHasBeenSet() const { return m_stackInstanceAccountHasBeenSet; }
|
||||
inline void SetStackInstanceAccount(const Aws::String& value) { m_stackInstanceAccountHasBeenSet = true; m_stackInstanceAccount = value; }
|
||||
inline void SetStackInstanceAccount(Aws::String&& value) { m_stackInstanceAccountHasBeenSet = true; m_stackInstanceAccount = std::move(value); }
|
||||
inline void SetStackInstanceAccount(const char* value) { m_stackInstanceAccountHasBeenSet = true; m_stackInstanceAccount.assign(value); }
|
||||
inline DescribeStackInstanceRequest& WithStackInstanceAccount(const Aws::String& value) { SetStackInstanceAccount(value); return *this;}
|
||||
inline DescribeStackInstanceRequest& WithStackInstanceAccount(Aws::String&& value) { SetStackInstanceAccount(std::move(value)); return *this;}
|
||||
inline DescribeStackInstanceRequest& WithStackInstanceAccount(const char* value) { SetStackInstanceAccount(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of a Region that's associated with this stack instance.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackInstanceRegion() const{ return m_stackInstanceRegion; }
|
||||
inline bool StackInstanceRegionHasBeenSet() const { return m_stackInstanceRegionHasBeenSet; }
|
||||
inline void SetStackInstanceRegion(const Aws::String& value) { m_stackInstanceRegionHasBeenSet = true; m_stackInstanceRegion = value; }
|
||||
inline void SetStackInstanceRegion(Aws::String&& value) { m_stackInstanceRegionHasBeenSet = true; m_stackInstanceRegion = std::move(value); }
|
||||
inline void SetStackInstanceRegion(const char* value) { m_stackInstanceRegionHasBeenSet = true; m_stackInstanceRegion.assign(value); }
|
||||
inline DescribeStackInstanceRequest& WithStackInstanceRegion(const Aws::String& value) { SetStackInstanceRegion(value); return *this;}
|
||||
inline DescribeStackInstanceRequest& WithStackInstanceRegion(Aws::String&& value) { SetStackInstanceRegion(std::move(value)); return *this;}
|
||||
inline DescribeStackInstanceRequest& WithStackInstanceRegion(const char* value) { SetStackInstanceRegion(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Service-managed permissions] Specifies whether you are acting as an account
|
||||
* administrator in the organization's management account or as a delegated
|
||||
* administrator in a member account.</p> <p>By default, <code>SELF</code> is
|
||||
* specified. Use <code>SELF</code> for stack sets with self-managed
|
||||
* permissions.</p> <ul> <li> <p>If you are signed in to the management account,
|
||||
* specify <code>SELF</code>.</p> </li> <li> <p>If you are signed in to a delegated
|
||||
* administrator account, specify <code>DELEGATED_ADMIN</code>.</p> <p>Your Amazon
|
||||
* Web Services account must be registered as a delegated administrator in the
|
||||
* management account. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html">Register
|
||||
* a delegated administrator</a> in the <i>CloudFormation User Guide</i>.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const CallAs& GetCallAs() const{ return m_callAs; }
|
||||
inline bool CallAsHasBeenSet() const { return m_callAsHasBeenSet; }
|
||||
inline void SetCallAs(const CallAs& value) { m_callAsHasBeenSet = true; m_callAs = value; }
|
||||
inline void SetCallAs(CallAs&& value) { m_callAsHasBeenSet = true; m_callAs = std::move(value); }
|
||||
inline DescribeStackInstanceRequest& WithCallAs(const CallAs& value) { SetCallAs(value); return *this;}
|
||||
inline DescribeStackInstanceRequest& WithCallAs(CallAs&& value) { SetCallAs(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackSetName;
|
||||
bool m_stackSetNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_stackInstanceAccount;
|
||||
bool m_stackInstanceAccountHasBeenSet = false;
|
||||
|
||||
Aws::String m_stackInstanceRegion;
|
||||
bool m_stackInstanceRegionHasBeenSet = false;
|
||||
|
||||
CallAs m_callAs;
|
||||
bool m_callAsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,64 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/StackInstance.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribeStackInstanceResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackInstanceResult();
|
||||
AWS_CLOUDFORMATION_API DescribeStackInstanceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeStackInstanceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The stack instance that matches the specified request parameters.</p>
|
||||
*/
|
||||
inline const StackInstance& GetStackInstance() const{ return m_stackInstance; }
|
||||
inline void SetStackInstance(const StackInstance& value) { m_stackInstance = value; }
|
||||
inline void SetStackInstance(StackInstance&& value) { m_stackInstance = std::move(value); }
|
||||
inline DescribeStackInstanceResult& WithStackInstance(const StackInstance& value) { SetStackInstance(value); return *this;}
|
||||
inline DescribeStackInstanceResult& WithStackInstance(StackInstance&& value) { SetStackInstance(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeStackInstanceResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeStackInstanceResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
StackInstance m_stackInstance;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,119 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/StackResourceDriftStatus.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribeStackResourceDriftsRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourceDriftsRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeStackResourceDrifts"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the stack for which you want drift information.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline DescribeStackResourceDriftsRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DescribeStackResourceDriftsRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DescribeStackResourceDriftsRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The resource drift status values to use as filters for the resource drift
|
||||
* results returned.</p> <ul> <li> <p> <code>DELETED</code>: The resource differs
|
||||
* from its expected template configuration in that the resource has been
|
||||
* deleted.</p> </li> <li> <p> <code>MODIFIED</code>: One or more resource
|
||||
* properties differ from their expected template values.</p> </li> <li> <p>
|
||||
* <code>IN_SYNC</code>: The resource's actual configuration matches its expected
|
||||
* template configuration.</p> </li> <li> <p> <code>NOT_CHECKED</code>:
|
||||
* CloudFormation doesn't currently return this value.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::Vector<StackResourceDriftStatus>& GetStackResourceDriftStatusFilters() const{ return m_stackResourceDriftStatusFilters; }
|
||||
inline bool StackResourceDriftStatusFiltersHasBeenSet() const { return m_stackResourceDriftStatusFiltersHasBeenSet; }
|
||||
inline void SetStackResourceDriftStatusFilters(const Aws::Vector<StackResourceDriftStatus>& value) { m_stackResourceDriftStatusFiltersHasBeenSet = true; m_stackResourceDriftStatusFilters = value; }
|
||||
inline void SetStackResourceDriftStatusFilters(Aws::Vector<StackResourceDriftStatus>&& value) { m_stackResourceDriftStatusFiltersHasBeenSet = true; m_stackResourceDriftStatusFilters = std::move(value); }
|
||||
inline DescribeStackResourceDriftsRequest& WithStackResourceDriftStatusFilters(const Aws::Vector<StackResourceDriftStatus>& value) { SetStackResourceDriftStatusFilters(value); return *this;}
|
||||
inline DescribeStackResourceDriftsRequest& WithStackResourceDriftStatusFilters(Aws::Vector<StackResourceDriftStatus>&& value) { SetStackResourceDriftStatusFilters(std::move(value)); return *this;}
|
||||
inline DescribeStackResourceDriftsRequest& AddStackResourceDriftStatusFilters(const StackResourceDriftStatus& value) { m_stackResourceDriftStatusFiltersHasBeenSet = true; m_stackResourceDriftStatusFilters.push_back(value); return *this; }
|
||||
inline DescribeStackResourceDriftsRequest& AddStackResourceDriftStatusFilters(StackResourceDriftStatus&& value) { m_stackResourceDriftStatusFiltersHasBeenSet = true; m_stackResourceDriftStatusFilters.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A string that identifies the next page of stack resource drift results.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
|
||||
inline DescribeStackResourceDriftsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeStackResourceDriftsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeStackResourceDriftsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The maximum number of results to be returned with a single call. If the
|
||||
* number of available results exceeds this maximum, the response includes a
|
||||
* <code>NextToken</code> value that you can assign to the <code>NextToken</code>
|
||||
* request parameter to get the next set of results.</p>
|
||||
*/
|
||||
inline int GetMaxResults() const{ return m_maxResults; }
|
||||
inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
|
||||
inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
|
||||
inline DescribeStackResourceDriftsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<StackResourceDriftStatus> m_stackResourceDriftStatusFilters;
|
||||
bool m_stackResourceDriftStatusFiltersHasBeenSet = false;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
bool m_nextTokenHasBeenSet = false;
|
||||
|
||||
int m_maxResults;
|
||||
bool m_maxResultsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <aws/cloudformation/model/StackResourceDrift.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribeStackResourceDriftsResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourceDriftsResult();
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourceDriftsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourceDriftsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>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 drift.</p> <p>For a given stack, there
|
||||
* will be one <code>StackResourceDrift</code> for each stack resource that has
|
||||
* been checked for drift. Resources that haven't yet been checked for drift aren't
|
||||
* included. Resources that do not currently support drift detection aren't
|
||||
* checked, and so not included. For a list of resources that support drift
|
||||
* detection, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import-supported-resources.html">Resource
|
||||
* type support for imports and drift detection</a>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<StackResourceDrift>& GetStackResourceDrifts() const{ return m_stackResourceDrifts; }
|
||||
inline void SetStackResourceDrifts(const Aws::Vector<StackResourceDrift>& value) { m_stackResourceDrifts = value; }
|
||||
inline void SetStackResourceDrifts(Aws::Vector<StackResourceDrift>&& value) { m_stackResourceDrifts = std::move(value); }
|
||||
inline DescribeStackResourceDriftsResult& WithStackResourceDrifts(const Aws::Vector<StackResourceDrift>& value) { SetStackResourceDrifts(value); return *this;}
|
||||
inline DescribeStackResourceDriftsResult& WithStackResourceDrifts(Aws::Vector<StackResourceDrift>&& value) { SetStackResourceDrifts(std::move(value)); return *this;}
|
||||
inline DescribeStackResourceDriftsResult& AddStackResourceDrifts(const StackResourceDrift& value) { m_stackResourceDrifts.push_back(value); return *this; }
|
||||
inline DescribeStackResourceDriftsResult& AddStackResourceDrifts(StackResourceDrift&& value) { m_stackResourceDrifts.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If the request doesn't return all the remaining results,
|
||||
* <code>NextToken</code> is set to a token. To retrieve the next set of results,
|
||||
* call <code>DescribeStackResourceDrifts</code> again and assign that token to the
|
||||
* request object's <code>NextToken</code> parameter. If the request returns all
|
||||
* results, <code>NextToken</code> is set to <code>null</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
|
||||
inline DescribeStackResourceDriftsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeStackResourceDriftsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeStackResourceDriftsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeStackResourceDriftsResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeStackResourceDriftsResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<StackResourceDrift> m_stackResourceDrifts;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,86 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for <a>DescribeStackResource</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeStackResourceInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeStackResourceRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourceRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeStackResource"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or the unique stack ID that's associated with the stack, which
|
||||
* aren't always interchangeable:</p> <ul> <li> <p>Running stacks: You can specify
|
||||
* either the stack's name or its unique stack ID.</p> </li> <li> <p>Deleted
|
||||
* stacks: You must specify the unique stack ID.</p> </li> </ul> <p>Default: There
|
||||
* is no default value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline DescribeStackResourceRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DescribeStackResourceRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DescribeStackResourceRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The logical name of the resource as specified in the template.</p>
|
||||
* <p>Default: There is no default value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetLogicalResourceId() const{ return m_logicalResourceId; }
|
||||
inline bool LogicalResourceIdHasBeenSet() const { return m_logicalResourceIdHasBeenSet; }
|
||||
inline void SetLogicalResourceId(const Aws::String& value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId = value; }
|
||||
inline void SetLogicalResourceId(Aws::String&& value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId = std::move(value); }
|
||||
inline void SetLogicalResourceId(const char* value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId.assign(value); }
|
||||
inline DescribeStackResourceRequest& WithLogicalResourceId(const Aws::String& value) { SetLogicalResourceId(value); return *this;}
|
||||
inline DescribeStackResourceRequest& WithLogicalResourceId(Aws::String&& value) { SetLogicalResourceId(std::move(value)); return *this;}
|
||||
inline DescribeStackResourceRequest& WithLogicalResourceId(const char* value) { SetLogicalResourceId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_logicalResourceId;
|
||||
bool m_logicalResourceIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,71 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/StackResourceDetail.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The output for a <a>DescribeStackResource</a> action.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeStackResourceOutput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeStackResourceResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourceResult();
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A <code>StackResourceDetail</code> structure containing the description of
|
||||
* the specified resource in the specified stack.</p>
|
||||
*/
|
||||
inline const StackResourceDetail& GetStackResourceDetail() const{ return m_stackResourceDetail; }
|
||||
inline void SetStackResourceDetail(const StackResourceDetail& value) { m_stackResourceDetail = value; }
|
||||
inline void SetStackResourceDetail(StackResourceDetail&& value) { m_stackResourceDetail = std::move(value); }
|
||||
inline DescribeStackResourceResult& WithStackResourceDetail(const StackResourceDetail& value) { SetStackResourceDetail(value); return *this;}
|
||||
inline DescribeStackResourceResult& WithStackResourceDetail(StackResourceDetail&& value) { SetStackResourceDetail(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeStackResourceResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeStackResourceResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
StackResourceDetail m_stackResourceDetail;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,111 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for <a>DescribeStackResources</a> action.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeStackResourcesInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeStackResourcesRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourcesRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeStackResources"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or the unique stack ID that is associated with the stack, which
|
||||
* aren't always interchangeable:</p> <ul> <li> <p>Running stacks: You can specify
|
||||
* either the stack's name or its unique stack ID.</p> </li> <li> <p>Deleted
|
||||
* stacks: You must specify the unique stack ID.</p> </li> </ul> <p>Default: There
|
||||
* is no default value.</p> <p>Required: Conditional. If you don't specify
|
||||
* <code>StackName</code>, you must specify <code>PhysicalResourceId</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline DescribeStackResourcesRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DescribeStackResourcesRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DescribeStackResourcesRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The logical name of the resource as specified in the template.</p>
|
||||
* <p>Default: There is no default value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetLogicalResourceId() const{ return m_logicalResourceId; }
|
||||
inline bool LogicalResourceIdHasBeenSet() const { return m_logicalResourceIdHasBeenSet; }
|
||||
inline void SetLogicalResourceId(const Aws::String& value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId = value; }
|
||||
inline void SetLogicalResourceId(Aws::String&& value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId = std::move(value); }
|
||||
inline void SetLogicalResourceId(const char* value) { m_logicalResourceIdHasBeenSet = true; m_logicalResourceId.assign(value); }
|
||||
inline DescribeStackResourcesRequest& WithLogicalResourceId(const Aws::String& value) { SetLogicalResourceId(value); return *this;}
|
||||
inline DescribeStackResourcesRequest& WithLogicalResourceId(Aws::String&& value) { SetLogicalResourceId(std::move(value)); return *this;}
|
||||
inline DescribeStackResourcesRequest& WithLogicalResourceId(const char* value) { SetLogicalResourceId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or unique identifier that corresponds to a physical instance ID of a
|
||||
* resource supported by CloudFormation.</p> <p>For example, for an Amazon Elastic
|
||||
* Compute Cloud (EC2) instance, <code>PhysicalResourceId</code> corresponds to the
|
||||
* <code>InstanceId</code>. You can pass the EC2 <code>InstanceId</code> to
|
||||
* <code>DescribeStackResources</code> to find which stack the instance belongs to
|
||||
* and what other resources are part of the stack.</p> <p>Required: Conditional. If
|
||||
* you don't specify <code>PhysicalResourceId</code>, you must specify
|
||||
* <code>StackName</code>.</p> <p>Default: There is no default value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPhysicalResourceId() const{ return m_physicalResourceId; }
|
||||
inline bool PhysicalResourceIdHasBeenSet() const { return m_physicalResourceIdHasBeenSet; }
|
||||
inline void SetPhysicalResourceId(const Aws::String& value) { m_physicalResourceIdHasBeenSet = true; m_physicalResourceId = value; }
|
||||
inline void SetPhysicalResourceId(Aws::String&& value) { m_physicalResourceIdHasBeenSet = true; m_physicalResourceId = std::move(value); }
|
||||
inline void SetPhysicalResourceId(const char* value) { m_physicalResourceIdHasBeenSet = true; m_physicalResourceId.assign(value); }
|
||||
inline DescribeStackResourcesRequest& WithPhysicalResourceId(const Aws::String& value) { SetPhysicalResourceId(value); return *this;}
|
||||
inline DescribeStackResourcesRequest& WithPhysicalResourceId(Aws::String&& value) { SetPhysicalResourceId(std::move(value)); return *this;}
|
||||
inline DescribeStackResourcesRequest& WithPhysicalResourceId(const char* value) { SetPhysicalResourceId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_logicalResourceId;
|
||||
bool m_logicalResourceIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_physicalResourceId;
|
||||
bool m_physicalResourceIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,73 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <aws/cloudformation/model/StackResource.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The output for a <a>DescribeStackResources</a> action.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeStackResourcesOutput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeStackResourcesResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourcesResult();
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourcesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeStackResourcesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of <code>StackResource</code> structures.</p>
|
||||
*/
|
||||
inline const Aws::Vector<StackResource>& GetStackResources() const{ return m_stackResources; }
|
||||
inline void SetStackResources(const Aws::Vector<StackResource>& value) { m_stackResources = value; }
|
||||
inline void SetStackResources(Aws::Vector<StackResource>&& value) { m_stackResources = std::move(value); }
|
||||
inline DescribeStackResourcesResult& WithStackResources(const Aws::Vector<StackResource>& value) { SetStackResources(value); return *this;}
|
||||
inline DescribeStackResourcesResult& WithStackResources(Aws::Vector<StackResource>&& value) { SetStackResources(std::move(value)); return *this;}
|
||||
inline DescribeStackResourcesResult& AddStackResources(const StackResource& value) { m_stackResources.push_back(value); return *this; }
|
||||
inline DescribeStackResourcesResult& AddStackResources(StackResource&& value) { m_stackResources.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeStackResourcesResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeStackResourcesResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<StackResource> m_stackResources;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,104 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/CallAs.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribeStackSetOperationRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackSetOperationRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeStackSetOperation"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or the unique stack ID of the stack set for the stack operation.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackSetName() const{ return m_stackSetName; }
|
||||
inline bool StackSetNameHasBeenSet() const { return m_stackSetNameHasBeenSet; }
|
||||
inline void SetStackSetName(const Aws::String& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = value; }
|
||||
inline void SetStackSetName(Aws::String&& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = std::move(value); }
|
||||
inline void SetStackSetName(const char* value) { m_stackSetNameHasBeenSet = true; m_stackSetName.assign(value); }
|
||||
inline DescribeStackSetOperationRequest& WithStackSetName(const Aws::String& value) { SetStackSetName(value); return *this;}
|
||||
inline DescribeStackSetOperationRequest& WithStackSetName(Aws::String&& value) { SetStackSetName(std::move(value)); return *this;}
|
||||
inline DescribeStackSetOperationRequest& WithStackSetName(const char* value) { SetStackSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique ID of the stack set operation.</p>
|
||||
*/
|
||||
inline const Aws::String& GetOperationId() const{ return m_operationId; }
|
||||
inline bool OperationIdHasBeenSet() const { return m_operationIdHasBeenSet; }
|
||||
inline void SetOperationId(const Aws::String& value) { m_operationIdHasBeenSet = true; m_operationId = value; }
|
||||
inline void SetOperationId(Aws::String&& value) { m_operationIdHasBeenSet = true; m_operationId = std::move(value); }
|
||||
inline void SetOperationId(const char* value) { m_operationIdHasBeenSet = true; m_operationId.assign(value); }
|
||||
inline DescribeStackSetOperationRequest& WithOperationId(const Aws::String& value) { SetOperationId(value); return *this;}
|
||||
inline DescribeStackSetOperationRequest& WithOperationId(Aws::String&& value) { SetOperationId(std::move(value)); return *this;}
|
||||
inline DescribeStackSetOperationRequest& WithOperationId(const char* value) { SetOperationId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Service-managed permissions] Specifies whether you are acting as an account
|
||||
* administrator in the organization's management account or as a delegated
|
||||
* administrator in a member account.</p> <p>By default, <code>SELF</code> is
|
||||
* specified. Use <code>SELF</code> for stack sets with self-managed
|
||||
* permissions.</p> <ul> <li> <p>If you are signed in to the management account,
|
||||
* specify <code>SELF</code>.</p> </li> <li> <p>If you are signed in to a delegated
|
||||
* administrator account, specify <code>DELEGATED_ADMIN</code>.</p> <p>Your Amazon
|
||||
* Web Services account must be registered as a delegated administrator in the
|
||||
* management account. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html">Register
|
||||
* a delegated administrator</a> in the <i>CloudFormation User Guide</i>.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const CallAs& GetCallAs() const{ return m_callAs; }
|
||||
inline bool CallAsHasBeenSet() const { return m_callAsHasBeenSet; }
|
||||
inline void SetCallAs(const CallAs& value) { m_callAsHasBeenSet = true; m_callAs = value; }
|
||||
inline void SetCallAs(CallAs&& value) { m_callAsHasBeenSet = true; m_callAs = std::move(value); }
|
||||
inline DescribeStackSetOperationRequest& WithCallAs(const CallAs& value) { SetCallAs(value); return *this;}
|
||||
inline DescribeStackSetOperationRequest& WithCallAs(CallAs&& value) { SetCallAs(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackSetName;
|
||||
bool m_stackSetNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_operationId;
|
||||
bool m_operationIdHasBeenSet = false;
|
||||
|
||||
CallAs m_callAs;
|
||||
bool m_callAsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,64 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/StackSetOperation.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribeStackSetOperationResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackSetOperationResult();
|
||||
AWS_CLOUDFORMATION_API DescribeStackSetOperationResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeStackSetOperationResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The specified stack set operation.</p>
|
||||
*/
|
||||
inline const StackSetOperation& GetStackSetOperation() const{ return m_stackSetOperation; }
|
||||
inline void SetStackSetOperation(const StackSetOperation& value) { m_stackSetOperation = value; }
|
||||
inline void SetStackSetOperation(StackSetOperation&& value) { m_stackSetOperation = std::move(value); }
|
||||
inline DescribeStackSetOperationResult& WithStackSetOperation(const StackSetOperation& value) { SetStackSetOperation(value); return *this;}
|
||||
inline DescribeStackSetOperationResult& WithStackSetOperation(StackSetOperation&& value) { SetStackSetOperation(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeStackSetOperationResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeStackSetOperationResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
StackSetOperation m_stackSetOperation;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,87 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/CallAs.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribeStackSetRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackSetRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeStackSet"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name or unique ID of the stack set whose description you want.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackSetName() const{ return m_stackSetName; }
|
||||
inline bool StackSetNameHasBeenSet() const { return m_stackSetNameHasBeenSet; }
|
||||
inline void SetStackSetName(const Aws::String& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = value; }
|
||||
inline void SetStackSetName(Aws::String&& value) { m_stackSetNameHasBeenSet = true; m_stackSetName = std::move(value); }
|
||||
inline void SetStackSetName(const char* value) { m_stackSetNameHasBeenSet = true; m_stackSetName.assign(value); }
|
||||
inline DescribeStackSetRequest& WithStackSetName(const Aws::String& value) { SetStackSetName(value); return *this;}
|
||||
inline DescribeStackSetRequest& WithStackSetName(Aws::String&& value) { SetStackSetName(std::move(value)); return *this;}
|
||||
inline DescribeStackSetRequest& WithStackSetName(const char* value) { SetStackSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>[Service-managed permissions] Specifies whether you are acting as an account
|
||||
* administrator in the organization's management account or as a delegated
|
||||
* administrator in a member account.</p> <p>By default, <code>SELF</code> is
|
||||
* specified. Use <code>SELF</code> for stack sets with self-managed
|
||||
* permissions.</p> <ul> <li> <p>If you are signed in to the management account,
|
||||
* specify <code>SELF</code>.</p> </li> <li> <p>If you are signed in to a delegated
|
||||
* administrator account, specify <code>DELEGATED_ADMIN</code>.</p> <p>Your Amazon
|
||||
* Web Services account must be registered as a delegated administrator in the
|
||||
* management account. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html">Register
|
||||
* a delegated administrator</a> in the <i>CloudFormation User Guide</i>.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const CallAs& GetCallAs() const{ return m_callAs; }
|
||||
inline bool CallAsHasBeenSet() const { return m_callAsHasBeenSet; }
|
||||
inline void SetCallAs(const CallAs& value) { m_callAsHasBeenSet = true; m_callAs = value; }
|
||||
inline void SetCallAs(CallAs&& value) { m_callAsHasBeenSet = true; m_callAs = std::move(value); }
|
||||
inline DescribeStackSetRequest& WithCallAs(const CallAs& value) { SetCallAs(value); return *this;}
|
||||
inline DescribeStackSetRequest& WithCallAs(CallAs&& value) { SetCallAs(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackSetName;
|
||||
bool m_stackSetNameHasBeenSet = false;
|
||||
|
||||
CallAs m_callAs;
|
||||
bool m_callAsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,64 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/StackSet.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribeStackSetResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStackSetResult();
|
||||
AWS_CLOUDFORMATION_API DescribeStackSetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeStackSetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The specified stack set.</p>
|
||||
*/
|
||||
inline const StackSet& GetStackSet() const{ return m_stackSet; }
|
||||
inline void SetStackSet(const StackSet& value) { m_stackSet = value; }
|
||||
inline void SetStackSet(StackSet&& value) { m_stackSet = std::move(value); }
|
||||
inline DescribeStackSetResult& WithStackSet(const StackSet& value) { SetStackSet(value); return *this;}
|
||||
inline DescribeStackSetResult& WithStackSet(StackSet&& value) { SetStackSet(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeStackSetResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeStackSetResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
StackSet m_stackSet;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,95 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The input for <a>DescribeStacks</a> action.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeStacksInput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeStacksRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStacksRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeStacks"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If you don't pass a parameter to <code>StackName</code>, the API
|
||||
* returns a response that describes all resources in the account, which can impact
|
||||
* performance. This requires <code>ListStacks</code> and
|
||||
* <code>DescribeStacks</code> permissions.</p> <p>Consider using the
|
||||
* <a>ListStacks</a> API if you're not passing a parameter to
|
||||
* <code>StackName</code>.</p> <p>The IAM policy below can be added to IAM policies
|
||||
* when you want to limit resource-level permissions and avoid returning a response
|
||||
* when no parameter is sent in the request:</p> <p>{ "Version": "2012-10-17",
|
||||
* "Statement": [{ "Effect": "Deny", "Action": "cloudformation:DescribeStacks",
|
||||
* "NotResource": "arn:aws:cloudformation:*:*:stack/ * / *" }] }</p> <p>The
|
||||
* name or the unique stack ID that's associated with the stack, which aren't
|
||||
* always interchangeable:</p> <ul> <li> <p>Running stacks: You can specify either
|
||||
* the stack's name or its unique stack ID.</p> </li> <li> <p>Deleted stacks: You
|
||||
* must specify the unique stack ID.</p> </li> </ul> <p>Default: There is no
|
||||
* default value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetStackName() const{ return m_stackName; }
|
||||
inline bool StackNameHasBeenSet() const { return m_stackNameHasBeenSet; }
|
||||
inline void SetStackName(const Aws::String& value) { m_stackNameHasBeenSet = true; m_stackName = value; }
|
||||
inline void SetStackName(Aws::String&& value) { m_stackNameHasBeenSet = true; m_stackName = std::move(value); }
|
||||
inline void SetStackName(const char* value) { m_stackNameHasBeenSet = true; m_stackName.assign(value); }
|
||||
inline DescribeStacksRequest& WithStackName(const Aws::String& value) { SetStackName(value); return *this;}
|
||||
inline DescribeStacksRequest& WithStackName(Aws::String&& value) { SetStackName(std::move(value)); return *this;}
|
||||
inline DescribeStacksRequest& WithStackName(const char* value) { SetStackName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A string that identifies the next page of stacks that you want to
|
||||
* retrieve.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
|
||||
inline DescribeStacksRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeStacksRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeStacksRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_stackName;
|
||||
bool m_stackNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
bool m_nextTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,89 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <aws/cloudformation/model/Stack.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The output for a <a>DescribeStacks</a> action.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cloudformation-2010-05-15/DescribeStacksOutput">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class DescribeStacksResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeStacksResult();
|
||||
AWS_CLOUDFORMATION_API DescribeStacksResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeStacksResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of stack structures.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Stack>& GetStacks() const{ return m_stacks; }
|
||||
inline void SetStacks(const Aws::Vector<Stack>& value) { m_stacks = value; }
|
||||
inline void SetStacks(Aws::Vector<Stack>&& value) { m_stacks = std::move(value); }
|
||||
inline DescribeStacksResult& WithStacks(const Aws::Vector<Stack>& value) { SetStacks(value); return *this;}
|
||||
inline DescribeStacksResult& WithStacks(Aws::Vector<Stack>&& value) { SetStacks(std::move(value)); return *this;}
|
||||
inline DescribeStacksResult& AddStacks(const Stack& value) { m_stacks.push_back(value); return *this; }
|
||||
inline DescribeStacksResult& AddStacks(Stack&& value) { m_stacks.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If the output exceeds 1 MB in size, a string that identifies the next page of
|
||||
* stacks. If no additional page exists, this value is null.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
|
||||
inline DescribeStacksResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline DescribeStacksResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline DescribeStacksResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeStacksResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeStacksResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<Stack> m_stacks;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/CloudFormationRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DescribeTypeRegistrationRequest : public CloudFormationRequest
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeTypeRegistrationRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "DescribeTypeRegistration"; }
|
||||
|
||||
AWS_CLOUDFORMATION_API Aws::String SerializePayload() const override;
|
||||
|
||||
protected:
|
||||
AWS_CLOUDFORMATION_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
|
||||
|
||||
public:
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The identifier for this registration request.</p> <p>This registration token
|
||||
* is generated by CloudFormation when you initiate a registration request using
|
||||
* <a>RegisterType</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRegistrationToken() const{ return m_registrationToken; }
|
||||
inline bool RegistrationTokenHasBeenSet() const { return m_registrationTokenHasBeenSet; }
|
||||
inline void SetRegistrationToken(const Aws::String& value) { m_registrationTokenHasBeenSet = true; m_registrationToken = value; }
|
||||
inline void SetRegistrationToken(Aws::String&& value) { m_registrationTokenHasBeenSet = true; m_registrationToken = std::move(value); }
|
||||
inline void SetRegistrationToken(const char* value) { m_registrationTokenHasBeenSet = true; m_registrationToken.assign(value); }
|
||||
inline DescribeTypeRegistrationRequest& WithRegistrationToken(const Aws::String& value) { SetRegistrationToken(value); return *this;}
|
||||
inline DescribeTypeRegistrationRequest& WithRegistrationToken(Aws::String&& value) { SetRegistrationToken(std::move(value)); return *this;}
|
||||
inline DescribeTypeRegistrationRequest& WithRegistrationToken(const char* value) { SetRegistrationToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_registrationToken;
|
||||
bool m_registrationTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,115 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cloudformation/CloudFormation_EXPORTS.h>
|
||||
#include <aws/cloudformation/model/RegistrationStatus.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cloudformation/model/ResponseMetadata.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Xml
|
||||
{
|
||||
class XmlDocument;
|
||||
} // namespace Xml
|
||||
} // namespace Utils
|
||||
namespace CloudFormation
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DescribeTypeRegistrationResult
|
||||
{
|
||||
public:
|
||||
AWS_CLOUDFORMATION_API DescribeTypeRegistrationResult();
|
||||
AWS_CLOUDFORMATION_API DescribeTypeRegistrationResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
AWS_CLOUDFORMATION_API DescribeTypeRegistrationResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The current status of the extension registration request.</p>
|
||||
*/
|
||||
inline const RegistrationStatus& GetProgressStatus() const{ return m_progressStatus; }
|
||||
inline void SetProgressStatus(const RegistrationStatus& value) { m_progressStatus = value; }
|
||||
inline void SetProgressStatus(RegistrationStatus&& value) { m_progressStatus = std::move(value); }
|
||||
inline DescribeTypeRegistrationResult& WithProgressStatus(const RegistrationStatus& value) { SetProgressStatus(value); return *this;}
|
||||
inline DescribeTypeRegistrationResult& WithProgressStatus(RegistrationStatus&& value) { SetProgressStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The description of the extension registration request.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline void SetDescription(const Aws::String& value) { m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_description.assign(value); }
|
||||
inline DescribeTypeRegistrationResult& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline DescribeTypeRegistrationResult& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline DescribeTypeRegistrationResult& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the extension being registered.</p> <p>For
|
||||
* registration requests with a <code>ProgressStatus</code> of other than
|
||||
* <code>COMPLETE</code>, this will be <code>null</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTypeArn() const{ return m_typeArn; }
|
||||
inline void SetTypeArn(const Aws::String& value) { m_typeArn = value; }
|
||||
inline void SetTypeArn(Aws::String&& value) { m_typeArn = std::move(value); }
|
||||
inline void SetTypeArn(const char* value) { m_typeArn.assign(value); }
|
||||
inline DescribeTypeRegistrationResult& WithTypeArn(const Aws::String& value) { SetTypeArn(value); return *this;}
|
||||
inline DescribeTypeRegistrationResult& WithTypeArn(Aws::String&& value) { SetTypeArn(std::move(value)); return *this;}
|
||||
inline DescribeTypeRegistrationResult& WithTypeArn(const char* value) { SetTypeArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of this specific version of the extension
|
||||
* being registered.</p> <p>For registration requests with a
|
||||
* <code>ProgressStatus</code> of other than <code>COMPLETE</code>, this will be
|
||||
* <code>null</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTypeVersionArn() const{ return m_typeVersionArn; }
|
||||
inline void SetTypeVersionArn(const Aws::String& value) { m_typeVersionArn = value; }
|
||||
inline void SetTypeVersionArn(Aws::String&& value) { m_typeVersionArn = std::move(value); }
|
||||
inline void SetTypeVersionArn(const char* value) { m_typeVersionArn.assign(value); }
|
||||
inline DescribeTypeRegistrationResult& WithTypeVersionArn(const Aws::String& value) { SetTypeVersionArn(value); return *this;}
|
||||
inline DescribeTypeRegistrationResult& WithTypeVersionArn(Aws::String&& value) { SetTypeVersionArn(std::move(value)); return *this;}
|
||||
inline DescribeTypeRegistrationResult& WithTypeVersionArn(const char* value) { SetTypeVersionArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
|
||||
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
|
||||
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
|
||||
inline DescribeTypeRegistrationResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
|
||||
inline DescribeTypeRegistrationResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
RegistrationStatus m_progressStatus;
|
||||
|
||||
Aws::String m_description;
|
||||
|
||||
Aws::String m_typeArn;
|
||||
|
||||
Aws::String m_typeVersionArn;
|
||||
|
||||
ResponseMetadata m_responseMetadata;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CloudFormation
|
||||
} // namespace Aws
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user