Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that AWS CloudFormation can respond with.

Structs

AccountGateResult

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.

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 FAILED, CloudFormation cancels the operation in that account and Region, and sets the stack set operation result status for that account and Region to FAILED.

For more information, see Configuring a target account gate in StackSets in the CloudFormation User Guide.

AccountLimit

The AccountLimit data type.

CloudFormation has the following limits per account:

• Number of concurrent resources

• Number of stacks

• Number of stack outputs

For more information about these account limits, and other CloudFormation limits, see Understand CloudFormation quotas in the CloudFormation User Guide.

AutoDeployment

\[Service-managed permissions\] Describes whether StackSets automatically deploys to Organizations accounts that are added to a target organization or organizational unit (OU).

BatchDescribeTypeConfigurationsError

Detailed information concerning an error generated during the setting of configuration data for a CloudFormation extension.

Change

The Change structure describes the changes CloudFormation will perform if you execute the change set.

ChangeSetHook

Specifies the resource, the hook, and the hook version to be invoked.

ChangeSetHookResourceTargetDetails

Specifies RESOURCE type target details for activated Hooks.

ChangeSetHookTargetDetails

Specifies target details for an activated hook.

ChangeSetSummary

The ChangeSetSummary structure describes a change set, its status, and the stack with which it's associated.

DeploymentTargets

\[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.

For update operations, you can specify either Accounts or OrganizationalUnitIds. For create and delete operations, specify OrganizationalUnitIds.

Export

The Export structure describes the exported output values for a stack.

HookResultSummary

Describes a Hook invocation, its status, and the reason for its status.

LoggingConfig

Contains logging configuration information for an extension.

ManagedExecution

Describes whether StackSets performs non-conflicting operations concurrently and queues conflicting operations.

ModuleInfo

Contains information about the module from which the resource was created, if the resource was created from a module included in the stack template.

For more information about modules, see Create reusable resource configurations that can be included across templates with CloudFormation modules in the CloudFormation User Guide.

OperationResultFilter

The status that operation results are filtered by.

Output

The Output data type.

Parameter

The Parameter data type.

ParameterConstraints

A set of criteria that CloudFormation uses to validate parameter values. Although other constraints might be defined in the stack template, CloudFormation returns only the AllowedValues property.

ParameterDeclaration

The ParameterDeclaration data type.

PhysicalResourceIdContextKeyValuePair

Context information that enables CloudFormation to uniquely identify a resource. CloudFormation uses context key-value pairs in cases where a resource's logical and physical IDs aren't enough to uniquely identify that resource. Each context key-value pair specifies a resource that contains the targeted resource.

PropertyDifference

Information about a resource property whose actual value differs from its expected value, as defined in the stack template and any values specified as template parameters. These will be present only for resources whose StackResourceDriftStatus is MODIFIED. For more information, see Detect unmanaged configuration changes to stacks and resources with drift detection.

RequiredActivatedType

For extensions that are modules, a public third-party extension that must be activated in your account in order for the module itself to be activated.

For more information, see Requirements for activating third-party public modules in the CloudFormation User Guide.

ResourceChange

The ResourceChange structure describes the resource and the action that CloudFormation will perform on it if you execute this change set.

ResourceChangeDetail

For a resource with Modify as the action, the ResourceChange structure describes the changes CloudFormation will make to that resource.

ResourceDefinition

A resource included in a generated template. This data type is used with the CreateGeneratedTemplate and UpdateGeneratedTemplate API actions.

ResourceDetail

Details about a resource in a generated template

ResourceIdentifierSummary

Describes the target resources of a specific type in your import template (for example, all AWS::S3::Bucket resources) and the properties you can provide during the import to identify resources of that type.

ResourceLocation

The location of the resource in a stack template.

ResourceMapping

Specifies the current source of the resource and the destination of where it will be moved to.

ResourceScanSummary

A summary of the resource scan. This is returned by the ListResourceScan API action.

ResourceTargetDefinition

The field that CloudFormation will change, such as the name of a resource's property, and whether the resource will be recreated.

ResourceToImport

Describes the target resource of an import operation.

RollbackConfiguration

Structure that contains the rollback triggers for CloudFormation to monitor during stack creation and updating operations, and for the specified monitoring period afterwards.

Rollback triggers enable you to have CloudFormation monitor the state of your application during stack creation and updating, and to roll back that operation if the application breaches the threshold of any of the alarms you've specified. For more information, see Roll back your CloudFormation stack on alarm breach with rollback triggers.

RollbackTrigger

A rollback trigger CloudFormation monitors during creation and updating of stacks. If any of the alarms you specify goes to ALARM state during the stack operation or within the specified monitoring period afterwards, CloudFormation rolls back the entire stack operation.

ScanFilter

A filter that is used to specify which resource types to scan.

ScannedResource

A scanned resource returned by ListResourceScanResources or ListResourceScanRelatedResources.

ScannedResourceIdentifier

Identifies a scanned resource. This is used with the ListResourceScanRelatedResources API action.

Stack

The Stack data type.

StackDefinition

Describes the stack and the template used by the stack.

StackDriftInformation

Contains information about whether the stack's actual configuration differs, or has drifted, from its expected configuration, as defined in the stack template and any values specified as template parameters. A stack is considered to have drifted if one or more of its resources have drifted.

StackDriftInformationSummary

Contains information about whether the stack's actual configuration differs, or has drifted, from its expected configuration, as defined in the stack template and any values specified as template parameters. A stack is considered to have drifted if one or more of its resources have drifted.

StackEvent

The StackEvent data type.

StackInstance

A CloudFormation stack, in a specific account and Region, that's part of a stack set operation. A stack instance is a reference to an attempted or actual stack in a given account within a given Region. A stack instance can exist without a stack—for example, if the stack couldn't be created for some reason. A stack instance is associated with only one stack set. Each stack instance contains the ID of its associated stack set, in addition to the ID of the actual stack and the stack status.

StackInstanceComprehensiveStatus

The detailed status of the stack instance.

StackInstanceFilter

The filter to apply to stack instances

StackInstanceResourceDriftsSummary

The structure containing summary information about resource drifts for a stack instance.

StackInstanceSummary

The structure that contains summary information about a stack instance.

StackRefactorAction

Describes the stack and the action that CloudFormation will perform on it if you execute the stack refactor.

StackRefactorSummary

The summary of a stack refactor operation.

StackResource

The StackResource data type.

StackResourceDetail

Contains detailed information about the specified stack resource.

StackResourceDrift

Contains the drift information for a resource that has been checked for drift. This includes actual and expected property values for resources in which CloudFormation has detected drift. Only resource properties explicitly defined in the stack template are checked for drift. For more information, see Detect unmanaged configuration changes to stacks and resources with drift detection.

Resources that don't currently support drift detection can't be checked. For a list of resources that support drift detection, see Resource type support for imports and drift detection.

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

StackResourceDriftInformation

Contains information about whether the resource's actual configuration differs, or has drifted, from its expected configuration.

StackResourceDriftInformationSummary

Summarizes information about whether the resource's actual configuration differs, or has drifted, from its expected configuration.

StackResourceSummary

Contains high-level information about the specified stack resource.

StackSet

A structure that contains information about a stack set. A stack set enables you to provision stacks into Amazon Web Services accounts and across Regions by using a single CloudFormation template. In the stack set, you specify the template to use, in addition to any parameters and capabilities that the template requires.

StackSetAutoDeploymentTargetSummary

One of the targets for the stack set. Returned by the ListStackSetAutoDeploymentTargets API operation.

StackSetDriftDetectionDetails

Detailed information about the drift status of the stack set.

For stack sets, contains information about the last completed drift operation performed on the stack set. Information about drift operations in-progress isn't included.

For stack set operations, includes information about drift operations currently being performed on the stack set.

For more information, see Performing drift detection on CloudFormation StackSets in the CloudFormation User Guide.

StackSetOperation

The structure that contains information about a stack set operation.

StackSetOperationPreferences

The user-specified preferences for how CloudFormation performs a stack set operation.

For more information about maximum concurrent accounts and failure tolerance, see Stack set operation options.

StackSetOperationPreferences don't apply to AutoDeployment, even if it's enabled.

StackSetOperationResultSummary

The structure that contains information about a specified operation's results for a given account in a given Region.

StackSetOperationStatusDetails

Detailed information about the StackSet operation.

StackSetOperationSummary

The structures that contain summary information about the specified operation.

StackSetSummary

The structures that contain summary information about the specified stack set.

StackSummary

The StackSummary Data Type

Tag

The Tag type enables you to specify a key-value pair that can be used to store information about an CloudFormation stack.

TemplateConfiguration

The configuration details of a generated template.

TemplateParameter

The TemplateParameter data type.

TemplateProgress

A summary of the progress of the template generation.

TemplateSummary

The summary of a generated template.

TemplateSummaryConfig

Options for the GetTemplateSummary API action.

TypeConfigurationDetails

Detailed information concerning the specification of a CloudFormation extension in a given account and Region.

For more information, see Edit configuration data for extensions in your account in the CloudFormation User Guide.

TypeConfigurationIdentifier

Identifying information for the configuration of a CloudFormation extension.

TypeFilters

Filter criteria to use in determining which extensions to return.

TypeSummary

Contains summary information about the specified CloudFormation extension.

TypeVersionSummary

Contains summary information about a specific version of a CloudFormation extension.

WarningDetail

The warnings generated for a specific resource for this generated template.

WarningProperty

A specific property that is impacted by a warning.

Warnings

Contains any warnings returned by the GetTemplateSummary API action.

Enums

AccountFilterType

When writing a match expression against AccountFilterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AccountGateStatus

When writing a match expression against AccountGateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AttributeChangeType

When writing a match expression against AttributeChangeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CallAs

When writing a match expression against CallAs, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Capability

When writing a match expression against Capability, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Category

When writing a match expression against Category, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ChangeAction

When writing a match expression against ChangeAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ChangeSetHooksStatus

When writing a match expression against ChangeSetHooksStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ChangeSetStatus

When writing a match expression against ChangeSetStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ChangeSetType

When writing a match expression against ChangeSetType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ChangeSource

When writing a match expression against ChangeSource, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ChangeType

When writing a match expression against ChangeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ConcurrencyMode

When writing a match expression against ConcurrencyMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeletionMode

When writing a match expression against DeletionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DeprecatedStatus

When writing a match expression against DeprecatedStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DetailedStatus

When writing a match expression against DetailedStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DifferenceType

When writing a match expression against DifferenceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EvaluationType

When writing a match expression against EvaluationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExecutionStatus

When writing a match expression against ExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GeneratedTemplateDeletionPolicy

When writing a match expression against GeneratedTemplateDeletionPolicy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GeneratedTemplateResourceStatus

When writing a match expression against GeneratedTemplateResourceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GeneratedTemplateStatus

When writing a match expression against GeneratedTemplateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GeneratedTemplateUpdateReplacePolicy

When writing a match expression against GeneratedTemplateUpdateReplacePolicy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

HandlerErrorCode

When writing a match expression against HandlerErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

HookFailureMode

When writing a match expression against HookFailureMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

HookInvocationPoint

When writing a match expression against HookInvocationPoint, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

HookStatus

When writing a match expression against HookStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

HookTargetType

When writing a match expression against HookTargetType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

IdentityProvider

When writing a match expression against IdentityProvider, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ListHookResultsTargetType

When writing a match expression against ListHookResultsTargetType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OnFailure

When writing a match expression against OnFailure, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OnStackFailure

When writing a match expression against OnStackFailure, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OperationResultFilterName

When writing a match expression against OperationResultFilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OperationStatus

When writing a match expression against OperationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OrganizationStatus

When writing a match expression against OrganizationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PermissionModels

When writing a match expression against PermissionModels, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PolicyAction

When writing a match expression against PolicyAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ProvisioningType

When writing a match expression against ProvisioningType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PublisherStatus

When writing a match expression against PublisherStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RegionConcurrencyType

When writing a match expression against RegionConcurrencyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RegistrationStatus

When writing a match expression against RegistrationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RegistryType

When writing a match expression against RegistryType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Replacement

When writing a match expression against Replacement, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RequiresRecreation

When writing a match expression against RequiresRecreation, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceAttribute

When writing a match expression against ResourceAttribute, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceScanStatus

When writing a match expression against ResourceScanStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceSignalStatus

When writing a match expression against ResourceSignalStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceStatus

When writing a match expression against ResourceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ScanType

When writing a match expression against ScanType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackDriftDetectionStatus

When writing a match expression against StackDriftDetectionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackDriftStatus

When writing a match expression against StackDriftStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackInstanceDetailedStatus

When writing a match expression against StackInstanceDetailedStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackInstanceFilterName

When writing a match expression against StackInstanceFilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackInstanceStatus

When writing a match expression against StackInstanceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackRefactorActionEntity

When writing a match expression against StackRefactorActionEntity, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackRefactorActionType

When writing a match expression against StackRefactorActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackRefactorDetection

When writing a match expression against StackRefactorDetection, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackRefactorExecutionStatus

When writing a match expression against StackRefactorExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackRefactorStatus

When writing a match expression against StackRefactorStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackResourceDriftStatus

When writing a match expression against StackResourceDriftStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackSetDriftDetectionStatus

When writing a match expression against StackSetDriftDetectionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackSetDriftStatus

When writing a match expression against StackSetDriftStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackSetOperationAction

When writing a match expression against StackSetOperationAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackSetOperationResultStatus

When writing a match expression against StackSetOperationResultStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackSetOperationStatus

When writing a match expression against StackSetOperationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackSetStatus

When writing a match expression against StackSetStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StackStatus

When writing a match expression against StackStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TemplateFormat

When writing a match expression against TemplateFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TemplateStage

When writing a match expression against TemplateStage, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ThirdPartyType

When writing a match expression against ThirdPartyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TypeTestsStatus

When writing a match expression against TypeTestsStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

VersionBump

When writing a match expression against VersionBump, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Visibility

When writing a match expression against Visibility, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WarningType

When writing a match expression against WarningType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.