Module aws_sdk_ssm::types

source ·
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§

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

    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.

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

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

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

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

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

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.