Module aws_sdk_ssm::types

Data structures used by operation inputs/outputs.

Modules

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

Structs

• AccountSharingInfo

  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.

• AutomationExecutionMetadata

  Details about a specific Automation execution.

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

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

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

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

• InstanceAssociationOutputUrl

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

• InstanceAssociationStatusInfo

  Status information about the association.

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

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

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

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

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

• MaintenanceWindowIdentity

  Information about the maintenance window.

• MaintenanceWindowIdentityForTarget

  The maintenance window to which the specified target belongs.

• MaintenanceWindowLambdaParameters

  The parameters for a LAMBDA task type.

• MaintenanceWindowRunCommandParameters

  The parameters for a RUN_COMMAND task type.

• MaintenanceWindowStepFunctionsParameters

  The parameters for a STEP_FUNCTIONS task.

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

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

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

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

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

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

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

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

• TargetLocation

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

Enums

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