Module types

The filter expression, AND or OR, to use when searching among a group of search strings in a resource. You can use two groupings per search each within parenthesis ().

SearchTermFilterExpression

Searches for a particular search term.

ServiceManagedEc2FleetConfiguration

The configuration details for a service managed Amazon EC2 fleet.

ServiceManagedEc2InstanceCapabilities

The Amazon EC2 instance capabilities.

ServiceManagedEc2InstanceMarketOptions

The details of the Amazon EC2 instance market options for a service managed fleet.

SessionActionSummary

The details of a session action.

SessionSummary

The summary of a session.

Statistics

A list of statistics for a session.

Stats

The minimum, maximum, average, and sum.

StepAmountCapability

The details outlining the minimum and maximum capability of a step.

StepAttributeCapability

The list of step attributes.

StepConsumer

The details of a step consumer.

StepDependency

The details of step dependency.

StepDetailsEntity

The details of a step entity.

StepDetailsError

The details of the step error.

StepDetailsIdentifiers

The details of identifiers for a step.

StepParameter

The details of a step parameter.

StepRequiredCapabilities

The details of required step capabilities.

StepSearchSummary

The details of a step search.

StepSummary

The details for a step.

StorageProfileSummary

The details of a storage profile.

StringFilterExpression

Searches for a particular string.

SyncInputJobAttachmentsSessionActionDefinition

The job attachment in a session action to sync.

SyncInputJobAttachmentsSessionActionDefinitionSummary

The details of a synced job attachment.

TaskRunManifestPropertiesRequest

The output manifest properties reported by the worker agent for a completed task run.

TaskRunManifestPropertiesResponse

The manifest properties for a task run, corresponding to the manifest properties in the job.

TaskRunSessionActionDefinition

The task, step, and parameters for the task run in the session action.

TaskRunSessionActionDefinitionSummary

The details of a task run in a session action.

TaskSearchSummary

The details of a task search.

TaskSummary

The details of a task.

UpdatedSessionActionInfo

The updated session action information as it relates to completion and progress of the session.

UserJobsFirst

Allows setting a specific user's job to run first.

VCpuCountRange

The allowable range of vCPU processing power for the fleet.

ValidationExceptionField

The details of a validation exception.

VpcConfiguration

The configuration options for a service managed fleet's VPC.

WindowsUser

The Windows user details.

WorkerAmountCapability

The details of the worker amount capability.

WorkerAttributeCapability

The details of the worker attribute capability.

WorkerCapabilities

The details for worker capabilities.

WorkerSearchSummary

The details of a worker search.

WorkerSessionSummary

Summarizes the session for a particular worker.

WorkerSummary

The summary of details for a worker.

Enums§

AcceleratorName: When writing a match expression against AcceleratorName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AcceleratorType: When writing a match expression against AcceleratorType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AssignedSessionActionDefinition: The definition of the assigned session action.
AutoScalingMode: When writing a match expression against AutoScalingMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AutoScalingStatus: When writing a match expression against AutoScalingStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
BudgetActionType: When writing a match expression against BudgetActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
BudgetSchedule: The start and end time of the budget.
BudgetStatus: When writing a match expression against BudgetStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ComparisonOperator: When writing a match expression against ComparisonOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CompletedStatus: When writing a match expression against CompletedStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ConflictExceptionReason: When writing a match expression against ConflictExceptionReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CpuArchitectureType: When writing a match expression against CpuArchitectureType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CreateJobTargetTaskRunStatus: When writing a match expression against CreateJobTargetTaskRunStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CustomerManagedFleetOperatingSystemFamily: When writing a match expression against CustomerManagedFleetOperatingSystemFamily, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DeadlinePrincipalType: When writing a match expression against DeadlinePrincipalType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DefaultQueueBudgetAction: When writing a match expression against DefaultQueueBudgetAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DependencyConsumerResolutionStatus: When writing a match expression against DependencyConsumerResolutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DesiredWorkerStatus: When writing a match expression against DesiredWorkerStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
Ec2MarketType: When writing a match expression against Ec2MarketType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
EnvironmentTemplateType: When writing a match expression against EnvironmentTemplateType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FileSystemLocationType: When writing a match expression against FileSystemLocationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetConfiguration: Fleet configuration details.
FleetStatus: When writing a match expression against FleetStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
GetJobEntityError: The error for the job entity.
JobAttachmentsFileSystem: When writing a match expression against JobAttachmentsFileSystem, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
JobEntity: The details of a job entity.
JobEntityErrorCode: When writing a match expression against JobEntityErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
JobEntityIdentifiersUnion: The details of a job entity identifier.
JobLifecycleStatus: When writing a match expression against JobLifecycleStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
JobParameter: The details of job parameters.
JobTargetTaskRunStatus: When writing a match expression against JobTargetTaskRunStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
JobTemplateType: When writing a match expression against JobTemplateType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LicenseEndpointStatus: When writing a match expression against LicenseEndpointStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LogicalOperator: When writing a match expression against LogicalOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
MembershipLevel: When writing a match expression against MembershipLevel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PathFormat: When writing a match expression against PathFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
Period: When writing a match expression against Period, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
QueueBlockedReason: When writing a match expression against QueueBlockedReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
QueueFleetAssociationStatus: When writing a match expression against QueueFleetAssociationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
QueueLimitAssociationStatus: When writing a match expression against QueueLimitAssociationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
QueueStatus: When writing a match expression against QueueStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
RunAs: When writing a match expression against RunAs, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SearchFilterExpression: The type of search filter to apply.
SearchSortExpression: The resources to search.
SearchTermMatchingType: When writing a match expression against SearchTermMatchingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ServiceManagedFleetOperatingSystemFamily: When writing a match expression against ServiceManagedFleetOperatingSystemFamily, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ServiceQuotaExceededExceptionReason: When writing a match expression against ServiceQuotaExceededExceptionReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SessionActionDefinition: The definition of the session action.
SessionActionDefinitionSummary: The details of a session action definition.
SessionActionStatus: When writing a match expression against SessionActionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SessionLifecycleStatus: When writing a match expression against SessionLifecycleStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SessionLifecycleTargetStatus: When writing a match expression against SessionLifecycleTargetStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SessionsStatisticsAggregationStatus: When writing a match expression against SessionsStatisticsAggregationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SessionsStatisticsResources: Specifies the fleet IDs or queue IDs to return statistics. You can specify only fleet IDs or queue IDS, not both.
SortOrder: When writing a match expression against SortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StepLifecycleStatus: When writing a match expression against StepLifecycleStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StepParameterType: When writing a match expression against StepParameterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StepTargetTaskRunStatus: When writing a match expression against StepTargetTaskRunStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StorageProfileOperatingSystemFamily: When writing a match expression against StorageProfileOperatingSystemFamily, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TagPropagationMode: When writing a match expression against TagPropagationMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TaskParameterValue: The data types for the task parameters.
TaskRunStatus: When writing a match expression against TaskRunStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TaskTargetRunStatus: When writing a match expression against TaskTargetRunStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
UpdateJobLifecycleStatus: When writing a match expression against UpdateJobLifecycleStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
UpdateQueueFleetAssociationStatus: When writing a match expression against UpdateQueueFleetAssociationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
UpdateQueueLimitAssociationStatus: When writing a match expression against UpdateQueueLimitAssociationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
UpdatedWorkerStatus: When writing a match expression against UpdatedWorkerStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
UsageGroupByField: When writing a match expression against UsageGroupByField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
UsageStatistic: When writing a match expression against UsageStatistic, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
UsageTrackingResource: The usage details of the allotted budget.
UsageType: When writing a match expression against UsageType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ValidationExceptionReason: When writing a match expression against ValidationExceptionReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
WorkerStatus: When writing a match expression against WorkerStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Module types

Module types Copy item path

Modules§

Structs§

Enums§

Module types