Module types

Expand description

Data structures used by operation inputs/outputs.

Modules§

builders: Builders
error: Error types that Amazon Simple Systems Manager (SSM) can respond with.

Structs§

Information includes the Amazon Web Services account ID where the current document is shared and the version shared with that account.

Activation

An activation registers one or more on-premises servers or virtual machines (VMs) with Amazon Web Services so that you can configure those servers or VMs using Run Command. A server or VM that has been registered with Amazon Web Services Systems Manager is called a managed node.

Alarm

A CloudWatch alarm you apply to an automation or command.

AlarmConfiguration

The details for the CloudWatch alarm you want to apply to an automation or command.

AlarmStateInformation

The details about the state of your CloudWatch alarm.

Association

Describes an association of a Amazon Web Services Systems Manager document (SSM document) and a managed node.

AssociationDescription

Describes the parameters for a document.

AssociationExecution

Includes information about the specified association.

AssociationExecutionFilter

Filters used in the request.

AssociationExecutionTarget

Includes information about the specified association execution.

AssociationExecutionTargetsFilter

Filters for the association execution.

AssociationFilter

Describes a filter.

AssociationOverview

Information about the association.

AssociationStatus

Describes an association status.

AssociationVersionInfo

Information about the association version.

AttachmentContent

A structure that includes attributes that describe a document attachment.

AttachmentInformation

An attribute of an attachment, such as the attachment name.

AttachmentsSource

Identifying information about a document attachment, including the file name and a key-value pair that identifies the location of an attachment to a document.

AutomationExecution

Detailed information about the current state of an individual Automation execution.

AutomationExecutionFilter

A filter used to match specific automation executions. This is used to limit the scope of Automation execution information returned.

AutomationExecutionInputs

Information about the optional inputs that can be specified for an automation execution preview.

AutomationExecutionMetadata

Details about a specific Automation execution.

AutomationExecutionPreview

Information about the results of the execution preview.

BaselineOverride

Defines the basic information about a patch baseline override.

CloudWatchOutputConfig

Configuration options for sending command output to Amazon CloudWatch Logs.

Command

Describes a command request.

CommandFilter

Describes a command filter.

A managed node ID can't be specified when a command status is Pending because the command hasn't run on the node yet.

CommandInvocation

An invocation is a copy of a command sent to a specific managed node. A command can apply to one or more managed nodes. A command invocation applies to one managed node. For example, if a user runs SendCommand against three managed nodes, then a command invocation is created for each requested managed node ID. A command invocation returns status and detail information about a command you ran.

CommandPlugin

Describes plugin details.

ComplianceExecutionSummary

A summary of the call execution that includes an execution ID, the type of execution (for example, Command), and the date/time of the execution using a datetime object that is saved in the following format: yyyy-MM-dd'T'HH:mm:ss'Z'

ComplianceItem

Information about the compliance as defined by the resource type. For example, for a patch resource type, Items includes information about the PatchSeverity, Classification, and so on.

ComplianceItemEntry

Information about a compliance item.

ComplianceStringFilter

One or more filters. Use a filter to return a more specific list of results.

ComplianceSummaryItem

A summary of compliance information by compliance type.

CompliantSummary

A summary of resources that are compliant. The summary is organized according to the resource count for each compliance type.

CreateAssociationBatchRequestEntry

Describes the association of a Amazon Web Services Systems Manager document (SSM document) and a managed node.

Credentials

The temporary security credentials, which include an access key ID, a secret access key, and a security (or session) token.

DescribeActivationsFilter

Filter for the DescribeActivation API.

DocumentDefaultVersionDescription

A default version of a document.

DocumentDescription

Describes an Amazon Web Services Systems Manager document (SSM document).

DocumentFilter

This data type is deprecated. Instead, use DocumentKeyValuesFilter.

DocumentIdentifier

Describes the name of a SSM document.

DocumentKeyValuesFilter

One or more filters. Use a filter to return a more specific list of documents.

For keys, you can specify one or more tags that have been applied to a document.

You can also use Amazon Web Services-provided keys, some of which have specific allowed values. These keys and their associated values are as follows:

DocumentType

ApplicationConfiguration
ApplicationConfigurationSchema
Automation
ChangeCalendar
Command
Package
Policy
Session

Owner

Note that only one Owner can be specified in a request. For example: Key=Owner,Values=Self.

Amazon
Private
Public
Self
ThirdParty

PlatformTypes

Linux
Windows

Name is another Amazon Web Services-provided key. If you use Name as a key, you can use a name prefix to return a list of documents. For example, in the Amazon Web Services CLI, to return a list of all documents that begin with Te, run the following command:

aws ssm list-documents --filters Key=Name,Values=Te

You can also use the TargetType Amazon Web Services-provided key. For a list of valid resource type values that can be used with this key, see Amazon Web Services resource and property types reference in the CloudFormation User Guide.

If you specify more than two keys, only documents that are identified by all the tags are returned in the results. If you specify more than two values for a key, documents that are identified by any of the values are returned in the results.

To specify a custom key-value pair, use the format Key=tag:tagName,Values=valueName.

For example, if you created a key called region and are using the Amazon Web Services CLI to call the list-documents command:

aws ssm list-documents --filters Key=tag:region,Values=east,west Key=Owner,Values=Self

DocumentMetadataResponseInfo

Details about the response to a document review request.

DocumentParameter

Parameters specified in a Systems Manager document that run on the server when the command is run.

DocumentRequires

An SSM document required by the current document.

DocumentReviewCommentSource

Information about comments added to a document review request.

DocumentReviewerResponseSource

Information about a reviewer's response to a document review request.

DocumentReviews

Information about a document approval review.

DocumentVersionInfo

Version information about the document.

EffectivePatch

The EffectivePatch structure defines metadata about a patch along with the approval state of the patch in a particular patch baseline. The approval state includes information about whether the patch is currently approved, due to be approved by a rule, explicitly approved, or explicitly rejected and the date the patch was or will be approved.

FailedCreateAssociation

Describes a failed association.

FailureDetails

Information about an Automation failure.

GetResourcePoliciesResponseEntry

A resource policy helps you to define the IAM entity (for example, an Amazon Web Services account) that can manage your Systems Manager resources. Currently, OpsItemGroup is the only resource that supports Systems Manager resource policies. The resource policy for OpsItemGroup enables Amazon Web Services accounts to view and interact with OpsCenter operational work items (OpsItems).

InstanceAggregatedAssociationOverview

Status information about the aggregated associations.

InstanceAssociation

One or more association documents on the managed node.

InstanceAssociationOutputLocation

An S3 bucket where you want to store the results of this request.

For the minimal permissions required to enable Amazon S3 output for an association, see Create an association (console) in the Systems Manager User Guide.

InstanceAssociationOutputUrl

The URL of S3 bucket where you want to store the results of this request.

InstanceAssociationStatusInfo

Status information about the association.

InstanceInfo

Details about a specific managed node.

InstanceInformation

Describes a filter for a specific list of managed nodes.

InstanceInformationFilter

Describes a filter for a specific list of managed nodes. You can filter node information by using tags. You specify tags by using a key-value mapping.

Use this operation instead of the DescribeInstanceInformationRequest$InstanceInformationFilterList method. The InstanceInformationFilterList method is a legacy method and doesn't support tags.

InstanceInformationStringFilter

The filters to describe or get information about your managed nodes.

InstancePatchState

Defines the high-level patch compliance state for a managed node, providing information about the number of installed, missing, not applicable, and failed patches along with metadata about the operation when this information was gathered for the managed node.

InstancePatchStateFilter

Defines a filter used in DescribeInstancePatchStatesForPatchGroup to scope down the information returned by the API.

Example: To filter for all managed nodes in a patch group having more than three patches with a FailedCount status, use the following for the filter:

Value for Key: FailedCount
Value for Type: GreaterThan
Value for Values: 3

InstanceProperty

An object containing various properties of a managed node.

InstancePropertyFilter

Describes a filter for a specific list of managed nodes. You can filter node information by using tags. You specify tags by using a key-value mapping.

InstancePropertyStringFilter

The filters to describe or get information about your managed nodes.

InventoryAggregator

Specifies the inventory type and attribute for the aggregation execution.

InventoryDeletionStatusItem

Status information returned by the DeleteInventory operation.

InventoryDeletionSummary

Information about the delete operation.

InventoryDeletionSummaryItem

Either a count, remaining count, or a version number in a delete inventory summary.

InventoryFilter

One or more filters. Use a filter to return a more specific list of results.

Example formats for the aws ssm get-inventory command:

--filters Key=AWS:InstanceInformation.AgentType,Values=amazon-ssm-agent,Type=Equal

--filters Key=AWS:InstanceInformation.AgentVersion,Values=3.3.2299.0,Type=Equal

--filters Key=AWS:InstanceInformation.ComputerName,Values=ip-192.0.2.0.us-east-2.compute.internal,Type=Equal

--filters Key=AWS:InstanceInformation.InstanceId,Values=i-0a4cd6ceffEXAMPLE,i-1a2b3c4d5e6EXAMPLE,Type=Equal

--filters Key=AWS:InstanceInformation.InstanceStatus,Values=Active,Type=Equal

--filters Key=AWS:InstanceInformation.IpAddress,Values=198.51.100.0,Type=Equal

--filters Key=AWS:InstanceInformation.PlatformName,Values="Amazon Linux",Type=Equal

--filters Key=AWS:InstanceInformation.PlatformType,Values=Linux,Type=Equal

--filters Key=AWS:InstanceInformation.PlatformVersion,Values=2023,Type=BeginWith

--filters Key=AWS:InstanceInformation.ResourceType,Values=EC2Instance,Type=Equal

InventoryGroup

A user-defined set of one or more filters on which to aggregate inventory data. Groups return a count of resources that match and don't match the specified criteria.

InventoryItem

Information collected from managed nodes based on your inventory policy document

InventoryItemAttribute

Attributes are the entries within the inventory item content. It contains name and value.

InventoryItemSchema

The inventory item schema definition. Users can use this to compose inventory query filters.

InventoryResultEntity

Inventory query results.

InventoryResultItem

The inventory result item.

LoggingInfo

Information about an Amazon Simple Storage Service (Amazon S3) bucket to write managed node-level logs to.

LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the OutputS3BucketName and OutputS3KeyPrefix options in the TaskInvocationParameters structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see MaintenanceWindowTaskInvocationParameters.

MaintenanceWindowAutomationParameters

The parameters for an AUTOMATION task type.

MaintenanceWindowExecution

Describes the information about an execution of a maintenance window.

MaintenanceWindowExecutionTaskIdentity

Information about a task execution performed as part of a maintenance window execution.

MaintenanceWindowExecutionTaskInvocationIdentity

Describes the information about a task invocation for a particular target as part of a task execution performed as part of a maintenance window execution.

MaintenanceWindowFilter

Filter used in the request. Supported filter keys depend on the API operation that includes the filter. API operations that use MaintenanceWindowFilter> include the following:

DescribeMaintenanceWindowExecutions
DescribeMaintenanceWindowExecutionTaskInvocations
DescribeMaintenanceWindowExecutionTasks
DescribeMaintenanceWindows
DescribeMaintenanceWindowTargets
DescribeMaintenanceWindowTasks

MaintenanceWindowIdentity

Information about the maintenance window.

MaintenanceWindowIdentityForTarget

The maintenance window to which the specified target belongs.

MaintenanceWindowLambdaParameters

The parameters for a LAMBDA task type.

For information about specifying and updating task parameters, see RegisterTaskWithMaintenanceWindow and UpdateMaintenanceWindowTask.

LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the OutputS3BucketName and OutputS3KeyPrefix options in the TaskInvocationParameters structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see MaintenanceWindowTaskInvocationParameters.

TaskParameters has been deprecated. To specify parameters to pass to a task when it runs, instead use the Parameters option in the TaskInvocationParameters structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see MaintenanceWindowTaskInvocationParameters.

For Lambda tasks, Systems Manager ignores any values specified for TaskParameters and LoggingInfo.

MaintenanceWindowRunCommandParameters

The parameters for a RUN_COMMAND task type.

For information about specifying and updating task parameters, see RegisterTaskWithMaintenanceWindow and UpdateMaintenanceWindowTask.

LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the OutputS3BucketName and OutputS3KeyPrefix options in the TaskInvocationParameters structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see MaintenanceWindowTaskInvocationParameters.

TaskParameters has been deprecated. To specify parameters to pass to a task when it runs, instead use the Parameters option in the TaskInvocationParameters structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see MaintenanceWindowTaskInvocationParameters.

For RUN_COMMAND tasks, Systems Manager uses specified values for TaskParameters and LoggingInfo only if no values are specified for TaskInvocationParameters.

MaintenanceWindowStepFunctionsParameters

The parameters for a STEP_FUNCTIONS task.

For information about specifying and updating task parameters, see RegisterTaskWithMaintenanceWindow and UpdateMaintenanceWindowTask.

LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the OutputS3BucketName and OutputS3KeyPrefix options in the TaskInvocationParameters structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see MaintenanceWindowTaskInvocationParameters.

TaskParameters has been deprecated. To specify parameters to pass to a task when it runs, instead use the Parameters option in the TaskInvocationParameters structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see MaintenanceWindowTaskInvocationParameters.

For Step Functions tasks, Systems Manager ignores any values specified for TaskParameters and LoggingInfo.

MaintenanceWindowTarget

The target registered with the maintenance window.

MaintenanceWindowTask

Information about a task defined for a maintenance window.

MaintenanceWindowTaskInvocationParameters

The parameters for task execution.

MaintenanceWindowTaskParameterValueExpression

Defines the values for a task parameter.

MetadataValue

Metadata to assign to an Application Manager application.

Node

Details about an individual managed node.

NodeAggregator

One or more aggregators for viewing counts of nodes using different dimensions.

NodeFilter

The filters for the operation.

NodeOwnerInfo

Information about ownership of a managed node.

NonCompliantSummary

A summary of resources that aren't compliant. The summary is organized according to resource type.

NotificationConfig

Configurations for sending notifications.

OpsAggregator

One or more aggregators for viewing counts of OpsData using different dimensions such as Source, CreatedTime, or Source and CreatedTime, to name a few.

OpsEntity

The result of the query.

OpsEntityItem

The OpsData summary.

OpsFilter

A filter for viewing OpsData summaries.

OpsItem

Operations engineers and IT professionals use Amazon Web Services Systems Manager OpsCenter to view, investigate, and remediate operational work items (OpsItems) impacting the performance and health of their Amazon Web Services resources. OpsCenter is integrated with Amazon EventBridge and Amazon CloudWatch. This means you can configure these services to automatically create an OpsItem in OpsCenter when a CloudWatch alarm enters the ALARM state or when EventBridge processes an event from any Amazon Web Services service that publishes events. Configuring Amazon CloudWatch alarms and EventBridge events to automatically create OpsItems allows you to quickly diagnose and remediate issues with Amazon Web Services resources from a single console.

To help you diagnose issues, each OpsItem includes contextually relevant information such as the name and ID of the Amazon Web Services resource that generated the OpsItem, alarm or event details, alarm history, and an alarm timeline graph. For the Amazon Web Services resource, OpsCenter aggregates information from Config, CloudTrail logs, and EventBridge, so you don't have to navigate across multiple console pages during your investigation. For more information, see Amazon Web Services Systems Manager OpsCenter in the Amazon Web Services Systems Manager User Guide.

OpsItemDataValue

An object that defines the value of the key and its type in the OperationalData map.

OpsItemEventFilter

Describes a filter for a specific list of OpsItem events. You can filter event information by using tags. You specify tags by using a key-value pair mapping.

OpsItemEventSummary

Summary information about an OpsItem event or that associated an OpsItem with a related item.

OpsItemFilter

Describes an OpsItem filter.

OpsItemIdentity

Information about the user or resource that created an OpsItem event.

OpsItemNotification

A notification about the OpsItem.

OpsItemRelatedItemSummary

Summary information about related-item resources for an OpsItem.

OpsItemRelatedItemsFilter

Describes a filter for a specific list of related-item resources.

OpsItemSummary

A count of OpsItems.

OpsMetadata

Operational metadata for an application in Application Manager.

OpsMetadataFilter

A filter to limit the number of OpsMetadata objects displayed.

OpsResultAttribute

The OpsItem data type to return.

OutputSource

Information about the source where the association execution details are stored.

Parameter

An Amazon Web Services Systems Manager parameter in Parameter Store.

ParameterHistory

Information about parameter usage.

ParameterInlinePolicy

One or more policies assigned to a parameter.

ParameterMetadata

Metadata includes information like the Amazon Resource Name (ARN) of the last user to update the parameter and the date and time the parameter was last used.

ParameterStringFilter

One or more filters. Use a filter to return a more specific list of results.

ParametersFilter

This data type is deprecated. Instead, use ParameterStringFilter.

ParentStepDetails

A detailed status of the parent step.

Patch

Represents metadata about a patch.

PatchBaselineIdentity

Defines the basic information about a patch baseline.

PatchComplianceData

Information about the state of a patch on a particular managed node as it relates to the patch baseline used to patch the node.

PatchFilter

Defines which patches should be included in a patch baseline.

A patch filter consists of a key and a set of values. The filter key is a patch property. For example, the available filter keys for WINDOWS are PATCH_SET, PRODUCT, PRODUCT_FAMILY, CLASSIFICATION, and MSRC_SEVERITY.

The filter values define a matching criterion for the patch property indicated by the key. For example, if the filter key is PRODUCT and the filter values are \["Office 2013", "Office 2016"\], then the filter accepts all patches where product name is either "Office 2013" or "Office 2016". The filter values can be exact values for the patch property given as a key, or a wildcard (*), which matches all values.

You can view lists of valid values for the patch properties by running the DescribePatchProperties command. For information about which patch properties can be used with each major operating system, see DescribePatchProperties.

PatchFilterGroup

A set of patch filters, typically used for approval rules.

PatchGroupPatchBaselineMapping

The mapping between a patch group and the patch baseline the patch group is registered with.

PatchOrchestratorFilter

Defines a filter used in Patch Manager APIs. Supported filter keys depend on the API operation that includes the filter. Patch Manager API operations that use PatchOrchestratorFilter include the following:

DescribeAvailablePatches
DescribeInstancePatches
DescribePatchBaselines
DescribePatchGroups

PatchRule

Defines an approval rule for a patch baseline.

PatchRuleGroup

A set of rules defining the approval rules for a patch baseline.

PatchSource

Information about the patches to use to update the managed nodes, including target operating systems and source repository. Applies to Linux managed nodes only.

PatchStatus

Information about the approval status of a patch.

ProgressCounters

An aggregate of step execution statuses displayed in the Amazon Web Services Systems Manager console for a multi-Region and multi-account Automation execution.

RegistrationMetadataItem

Reserved for internal use.

RelatedOpsItem

An OpsItems that shares something in common with the current OpsItem. For example, related OpsItems can include OpsItems with similar error messages, impacted resources, or statuses for the impacted resource.

ResolvedTargets

Information about targets that resolved during the Automation execution.

ResourceComplianceSummaryItem

Compliance summary information for a specific resource.

ResourceDataSyncAwsOrganizationsSource

Information about the AwsOrganizationsSource resource data sync source. A sync source of this type can synchronize data from Organizations or, if an Amazon Web Services organization isn't present, from multiple Amazon Web Services Regions.

ResourceDataSyncDestinationDataSharing

Synchronize Amazon Web Services Systems Manager Inventory data from multiple Amazon Web Services accounts defined in Organizations to a centralized Amazon S3 bucket. Data is synchronized to individual key prefixes in the central bucket. Each key prefix represents a different Amazon Web Services account ID.

ResourceDataSyncItem

Information about a resource data sync configuration, including its current status and last successful sync.

ResourceDataSyncOrganizationalUnit

The Organizations organizational unit data source for the sync.

ResourceDataSyncS3Destination

Information about the target S3 bucket for the resource data sync.

ResourceDataSyncSource

Information about the source of the data included in the resource data sync.

ResourceDataSyncSourceWithState

The data type name for including resource data sync state. There are four sync states:

OrganizationNotExists (Your organization doesn't exist)

NoPermissions (The system can't locate the service-linked role. This role is automatically created when a user creates a resource data sync in Amazon Web Services Systems Manager Explorer.)

InvalidOrganizationalUnit (You specified or selected an invalid unit in the resource data sync configuration.)

TrustedAccessDisabled (You disabled Systems Manager access in the organization in Organizations.)

ResultAttribute

The inventory item result attribute.

ReviewInformation

Information about the result of a document review request.

Runbook

Information about an Automation runbook used in a runbook workflow in Change Manager.

The Automation runbooks specified for the runbook workflow can't run until all required approvals for the change request have been received.

S3OutputLocation

An S3 bucket where you want to store the results of this request.

S3OutputUrl

A URL for the Amazon Web Services Systems Manager (Systems Manager) bucket where you want to store the results of this request.

ScheduledWindowExecution

Information about a scheduled execution for a maintenance window.

ServiceSetting

The service setting data structure.

ServiceSetting is an account-level setting for an Amazon Web Services service. This setting defines how a user interacts with or uses a service or a feature of a service. For example, if an Amazon Web Services service charges money to the account based on feature or service usage, then the Amazon Web Services service team might create a default setting of "false". This means the user can't use this feature unless they change the setting to "true" and intentionally opt in for a paid feature.

Services map a SettingId object to a setting value. Amazon Web Services services teams define the default value for a SettingId. You can't create a new SettingId, but you can overwrite the default value if you have the ssm:UpdateServiceSetting permission for the setting. Use the UpdateServiceSetting API operation to change the default setting. Or, use the ResetServiceSetting to change the value back to the original value defined by the Amazon Web Services service team.

Session

Information about a Session Manager connection to a managed node.

SessionFilter

Describes a filter for Session Manager information.

SessionManagerOutputUrl

Reserved for future use.

SeveritySummary

The number of managed nodes found for each patch severity level defined in the request filter.

StepExecution

Detailed information about an the execution state of an Automation step.

StepExecutionFilter

A filter to limit the amount of step execution information returned by the call.

Tag

Metadata that you assign to your Amazon Web Services resources. Tags enable you to categorize your resources in different ways, for example, by purpose, owner, or environment. In Amazon Web Services Systems Manager, you can apply tags to Systems Manager documents (SSM documents), managed nodes, maintenance windows, parameters, patch baselines, OpsItems, and OpsMetadata.

Target

An array of search criteria that targets managed nodes using a key-value pair that you specify.

One or more targets must be specified for maintenance window Run Command-type tasks. Depending on the task, targets are optional for other maintenance window task types (Automation, Lambda, and Step Functions). For more information about running tasks that don't specify targets, see Registering maintenance window tasks without targets in the Amazon Web Services Systems Manager User Guide.

Supported formats include the following.

For all Systems Manager tools:

Key=tag-key,Values=tag-value-1,tag-value-2

For Automation and Change Manager:

Key=tag:tag-key,Values=tag-value
Key=ResourceGroup,Values=resource-group-name
Key=ParameterValues,Values=value-1,value-2,value-3
To target all instances in the Amazon Web Services Region:
- Key=AWS::EC2::Instance,Values=*
- Key=InstanceIds,Values=*

For Run Command and Maintenance Windows:

Key=InstanceIds,Values=instance-id-1,instance-id-2,instance-id-3
Key=tag:tag-key,Values=tag-value-1,tag-value-2
Key=resource-groups:Name,Values=resource-group-name
Additionally, Maintenance Windows support targeting resource types:
- Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2

For State Manager:

Key=InstanceIds,Values=instance-id-1,instance-id-2,instance-id-3
Key=tag:tag-key,Values=tag-value-1,tag-value-2
To target all instances in the Amazon Web Services Region:
- Key=InstanceIds,Values=*

For more information about how to send commands that target managed nodes using Key,Value parameters, see Targeting multiple managed nodes in the Amazon Web Services Systems Manager User Guide.

TargetLocation

The combination of Amazon Web Services Regions and Amazon Web Services accounts targeted by the current Automation execution.

TargetPreview

Information about the resources that would be included in the actual runbook execution, if it were to be run.

Enums§

AccessRequestStatus: When writing a match expression against AccessRequestStatus, 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.
AccessType: When writing a match expression against AccessType, 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.
AssociationComplianceSeverity: When writing a match expression against AssociationComplianceSeverity, 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.
AssociationExecutionFilterKey: When writing a match expression against AssociationExecutionFilterKey, 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.
AssociationExecutionTargetsFilterKey: When writing a match expression against AssociationExecutionTargetsFilterKey, 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.
AssociationFilterKey: When writing a match expression against AssociationFilterKey, 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.
AssociationFilterOperatorType: When writing a match expression against AssociationFilterOperatorType, 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.
AssociationStatusName: When writing a match expression against AssociationStatusName, 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.
AssociationSyncCompliance: When writing a match expression against AssociationSyncCompliance, 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.
AttachmentHashType: When writing a match expression against AttachmentHashType, 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.
AttachmentsSourceKey: When writing a match expression against AttachmentsSourceKey, 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.
AutomationExecutionFilterKey: When writing a match expression against AutomationExecutionFilterKey, 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.
AutomationExecutionStatus: When writing a match expression against AutomationExecutionStatus, 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.
AutomationSubtype: When writing a match expression against AutomationSubtype, 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.
AutomationType: When writing a match expression against AutomationType, 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.
CalendarState: When writing a match expression against CalendarState, 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.
CommandFilterKey: When writing a match expression against CommandFilterKey, 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.
CommandInvocationStatus: When writing a match expression against CommandInvocationStatus, 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.
CommandPluginStatus: When writing a match expression against CommandPluginStatus, 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.
CommandStatus: When writing a match expression against CommandStatus, 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.
ComplianceQueryOperatorType: When writing a match expression against ComplianceQueryOperatorType, 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.
ComplianceSeverity: When writing a match expression against ComplianceSeverity, 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.
ComplianceStatus: When writing a match expression against ComplianceStatus, 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.
ComplianceUploadType: When writing a match expression against ComplianceUploadType, 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.
ConnectionStatus: When writing a match expression against ConnectionStatus, 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.
DescribeActivationsFilterKeys: When writing a match expression against DescribeActivationsFilterKeys, 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.
DocumentFilterKey: When writing a match expression against DocumentFilterKey, 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.
DocumentFormat: When writing a match expression against DocumentFormat, 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.
DocumentHashType: When writing a match expression against DocumentHashType, 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.
DocumentMetadataEnum: When writing a match expression against DocumentMetadataEnum, 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.
DocumentParameterType: When writing a match expression against DocumentParameterType, 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.
DocumentPermissionType: When writing a match expression against DocumentPermissionType, 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.
DocumentReviewAction: When writing a match expression against DocumentReviewAction, 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.
DocumentReviewCommentType: When writing a match expression against DocumentReviewCommentType, 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.
DocumentStatus: When writing a match expression against DocumentStatus, 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.
DocumentType: When writing a match expression against DocumentType, 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.
ExecutionInputs: Information about the inputs for an execution preview.
ExecutionMode: When writing a match expression against ExecutionMode, 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.
ExecutionPreview: Information about the changes that would be made if an execution were run.
ExecutionPreviewStatus: When writing a match expression against ExecutionPreviewStatus, 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.
ExternalAlarmState: When writing a match expression against ExternalAlarmState, 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.
Fault: When writing a match expression against Fault, 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.
ImpactType: When writing a match expression against ImpactType, 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.
InstanceInformationFilterKey: When writing a match expression against InstanceInformationFilterKey, 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.
InstancePatchStateOperatorType: When writing a match expression against InstancePatchStateOperatorType, 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.
InstancePropertyFilterKey: When writing a match expression against InstancePropertyFilterKey, 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.
InstancePropertyFilterOperator: When writing a match expression against InstancePropertyFilterOperator, 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.
InventoryAttributeDataType: When writing a match expression against InventoryAttributeDataType, 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.
InventoryDeletionStatus: When writing a match expression against InventoryDeletionStatus, 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.
InventoryQueryOperatorType: When writing a match expression against InventoryQueryOperatorType, 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.
InventorySchemaDeleteOption: When writing a match expression against InventorySchemaDeleteOption, 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.
LastResourceDataSyncStatus: When writing a match expression against LastResourceDataSyncStatus, 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.
MaintenanceWindowExecutionStatus: When writing a match expression against MaintenanceWindowExecutionStatus, 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.
MaintenanceWindowResourceType: When writing a match expression against MaintenanceWindowResourceType, 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.
MaintenanceWindowTaskCutoffBehavior: When writing a match expression against MaintenanceWindowTaskCutoffBehavior, 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.
MaintenanceWindowTaskType: When writing a match expression against MaintenanceWindowTaskType, 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.
ManagedStatus: When writing a match expression against ManagedStatus, 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.
NodeAggregatorType: When writing a match expression against NodeAggregatorType, 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.
NodeAttributeName: When writing a match expression against NodeAttributeName, 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.
NodeFilterKey: When writing a match expression against NodeFilterKey, 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.
NodeFilterOperatorType: When writing a match expression against NodeFilterOperatorType, 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.
NodeType: Information about a managed node's type.
NodeTypeName: When writing a match expression against NodeTypeName, 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.
NotificationEvent: When writing a match expression against NotificationEvent, 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.
NotificationType: When writing a match expression against NotificationType, 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.
OperatingSystem: When writing a match expression against OperatingSystem, 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.
OpsFilterOperatorType: When writing a match expression against OpsFilterOperatorType, 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.
OpsItemDataType: When writing a match expression against OpsItemDataType, 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.
OpsItemEventFilterKey: When writing a match expression against OpsItemEventFilterKey, 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.
OpsItemEventFilterOperator: When writing a match expression against OpsItemEventFilterOperator, 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.
OpsItemFilterKey: When writing a match expression against OpsItemFilterKey, 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.
OpsItemFilterOperator: When writing a match expression against OpsItemFilterOperator, 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.
OpsItemRelatedItemsFilterKey: When writing a match expression against OpsItemRelatedItemsFilterKey, 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.
OpsItemRelatedItemsFilterOperator: When writing a match expression against OpsItemRelatedItemsFilterOperator, 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.
OpsItemStatus: When writing a match expression against OpsItemStatus, 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.
ParameterTier: When writing a match expression against ParameterTier, 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.
ParameterType: When writing a match expression against ParameterType, 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.
ParametersFilterKey: When writing a match expression against ParametersFilterKey, 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.
PatchAction: When writing a match expression against PatchAction, 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.
PatchComplianceDataState: When writing a match expression against PatchComplianceDataState, 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.
PatchComplianceLevel: When writing a match expression against PatchComplianceLevel, 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.
PatchComplianceStatus: When writing a match expression against PatchComplianceStatus, 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.
PatchDeploymentStatus: When writing a match expression against PatchDeploymentStatus, 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.
PatchFilterKey: When writing a match expression against PatchFilterKey, 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.
PatchOperationType: When writing a match expression against PatchOperationType, 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.
PatchProperty: When writing a match expression against PatchProperty, 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.
PatchSet: When writing a match expression against PatchSet, 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.
PingStatus: When writing a match expression against PingStatus, 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.
PlatformType: When writing a match expression against PlatformType, 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.
RebootOption: When writing a match expression against RebootOption, 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.
ResourceDataSyncS3Format: When writing a match expression against ResourceDataSyncS3Format, 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.
ResourceType: When writing a match expression against ResourceType, 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.
ResourceTypeForTagging: When writing a match expression against ResourceTypeForTagging, 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.
ReviewStatus: When writing a match expression against ReviewStatus, 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.
SessionFilterKey: When writing a match expression against SessionFilterKey, 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.
SessionState: When writing a match expression against SessionState, 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.
SessionStatus: When writing a match expression against SessionStatus, 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.
SignalType: When writing a match expression against SignalType, 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.
SourceType: When writing a match expression against SourceType, 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.
StepExecutionFilterKey: When writing a match expression against StepExecutionFilterKey, 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.
StopType: When writing a match expression against StopType, 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.

Module typesCopy item path

Modules§

Structs§

Enums§

Module types