Module aws_sdk_cloudformation::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.

• AccountLimit

  The AccountLimit data type.

• 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.

• Export

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

• 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.

• 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 Detecting Unregulated Configuration Changes to Stacks and Resources.

• 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.

• 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.

• 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 containing the rollback triggers for CloudFormation to monitor during stack creation and updating operations, and for the specified monitoring period afterwards.

• 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.

• 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.

• 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

  An 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.

• 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 Detecting Unregulated Configuration Changes to Stacks and Resources.

• 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.

• StackSetOperation

  The structure that contains information about a stack set operation.

• StackSetOperationPreferences

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

• 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.

• 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.
• 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.
• 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.
• 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.
• 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.