Expand description
Data structures used by operation inputs/outputs.
Modules§
Structs§
- Action
Source A structure describing the source of an action.
- Action
Summary Lists the properties of an action. An action represents an action or activity. Some examples are a workflow step and a model deployment. Generally, an action involves at least one input artifact or output artifact.
- Additional
Inference Specification Definition A structure of additional Inference Specification. Additional Inference Specification specifies details about inference jobs that can be run with models based on this model package
- Additional
Model Data Source Data sources that are available to your model in addition to the one that you specify for
ModelDataSourcewhen you use theCreateModelaction.- Additional
S3Data Source A data source used for training or inference that is in addition to the input dataset or model data.
- Agent
Version Edge Manager agent version.
- Alarm
An Amazon CloudWatch alarm configured to monitor metrics on an endpoint.
- Alarm
Details The details of the alarm to monitor during the AMI update.
- Algorithm
Specification Specifies the training algorithm to use in a CreateTrainingJob request.
SageMaker uses its own SageMaker account credentials to pull and access built-in algorithms so built-in algorithms are universally accessible across all Amazon Web Services accounts. As a result, built-in algorithms have standard, unrestricted access. You cannot restrict built-in algorithms using IAM roles. Use custom algorithms if you require specific access controls.
For more information about algorithms provided by SageMaker, see Algorithms. For information about using your own algorithms, see Using Your Own Algorithms with Amazon SageMaker.
- Algorithm
Status Details Specifies the validation and image scan statuses of the algorithm.
- Algorithm
Status Item Represents the overall status of an algorithm.
- Algorithm
Summary Provides summary information about an algorithm.
- Algorithm
Validation Profile Defines a training job and a batch transform job that SageMaker runs to validate your algorithm.
The data provided in the validation profile is made available to your buyers on Amazon Web Services Marketplace.
- Algorithm
Validation Specification Specifies configurations for one or more training jobs that SageMaker runs to test the algorithm.
- AmazonQ
Settings A collection of settings that configure the Amazon Q experience within the domain.
- Annotation
Consolidation Config Configures how labels are consolidated across human workers and processes output data.
- AppDetails
Details about an Amazon SageMaker AI app.
- AppImage
Config Details The configuration for running a SageMaker AI image as a KernelGateway app.
- AppLifecycle
Management Settings that are used to configure and manage the lifecycle of Amazon SageMaker Studio applications.
- AppSpecification
Configuration to run a processing job in a specified container image.
- Artifact
Source A structure describing the source of an artifact.
- Artifact
Source Type The ID and ID type of an artifact source.
- Artifact
Summary Lists a summary of the properties of an artifact. An artifact represents a URI addressable object or data. Some examples are a dataset and a model.
- Association
Summary Lists a summary of the properties of an association. An association is an entity that links other lineage or experiment entities. An example would be an association between a training job and a model.
- Async
Inference Client Config Configures the behavior of the client used by SageMaker to interact with the model container during asynchronous inference.
- Async
Inference Config Specifies configuration for how an endpoint performs asynchronous inference.
- Async
Inference Notification Config Specifies the configuration for notifications of inference results for asynchronous inference.
- Async
Inference Output Config Specifies the configuration for asynchronous inference invocation outputs.
- Athena
Dataset Definition Configuration for Athena Dataset Definition input.
- Auto
MlAlgorithm Config The selection of algorithms trained on your dataset to generate the model candidates for an Autopilot job.
- Auto
MlCandidate Information about a candidate produced by an AutoML training job, including its status, steps, and other properties.
- Auto
MlCandidate Generation Config Stores the configuration information for how a candidate is generated (optional).
- Auto
MlCandidate Step Information about the steps for a candidate and what step it is working on.
- Auto
MlChannel A channel is a named input source that training algorithms can consume. The validation dataset size is limited to less than 2 GB. The training dataset size must be less than 100 GB. For more information, see Channel.
A validation dataset must contain the same headers as the training dataset.
- Auto
MlCompute Config This data type is intended for use exclusively by SageMaker Canvas and cannot be used in other contexts at the moment.
Specifies the compute configuration for an AutoML job V2.
- Auto
MlContainer Definition A list of container definitions that describe the different containers that make up an AutoML candidate. For more information, see ContainerDefinition.
- Auto
MlData Source The data source for the Autopilot job.
- Auto
MlData Split Config This structure specifies how to split the data into train and validation datasets.
The validation and training datasets must contain the same headers. For jobs created by calling
CreateAutoMLJob, the validation dataset must be less than 2 GB in size.- Auto
MlJob Artifacts The artifacts that are generated during an AutoML job.
- Auto
MlJob Channel A channel is a named input source that training algorithms can consume. This channel is used for AutoML jobs V2 (jobs created by calling CreateAutoMLJobV2).
- Auto
MlJob Completion Criteria How long a job is allowed to run, or how many candidates a job is allowed to generate.
- Auto
MlJob Config A collection of settings used for an AutoML job.
- Auto
MlJob Objective Specifies a metric to minimize or maximize as the objective of an AutoML job.
- Auto
MlJob Step Metadata Metadata for an AutoML job step.
- Auto
MlJob Summary Provides a summary about an AutoML job.
- Auto
MlOutput Data Config The output data configuration.
- Auto
MlPartial Failure Reason The reason for a partial failure of an AutoML job.
- Auto
MlResolved Attributes The resolved attributes used to configure an AutoML job V2.
- Auto
MlSecurity Config Security options.
- Auto
Mls3 Data Source Describes the Amazon S3 data source.
- Auto
Parameter The name and an example value of the hyperparameter that you want to use in Autotune. If Automatic model tuning (AMT) determines that your hyperparameter is eligible for Autotune, an optimal hyperparameter range is selected for you.
- Auto
Rollback Config Automatic rollback configuration for handling endpoint deployment failures and recovery.
- Autotune
A flag to indicate if you want to use Autotune to automatically find optimal values for the following fields:
-
ParameterRanges: The names and ranges of parameters that a hyperparameter tuning job can optimize.
-
ResourceLimits: The maximum resources that can be used for a training job. These resources include the maximum number of training jobs, the maximum runtime of a tuning job, and the maximum number of training jobs to run at the same time.
-
TrainingJobEarlyStoppingType: A flag that specifies whether or not to use early stopping for training jobs launched by a hyperparameter tuning job.
-
RetryStrategy: The number of times to retry a training job.
-
Strategy: Specifies how hyperparameter tuning chooses the combinations of hyperparameter values to use for the training jobs that it launches.
-
ConvergenceDetected: A flag to indicate that Automatic model tuning (AMT) has detected model convergence.
-
- Batch
Data Capture Config Configuration to control how SageMaker captures inference data for batch transform jobs.
- Batch
Delete Cluster Nodes Error Represents an error encountered when deleting a node from a SageMaker HyperPod cluster.
- Batch
Describe Model Package Error The error code and error description associated with the resource.
- Batch
Describe Model Package Summary Provides summary information about the model package.
- Batch
Transform Input Input object for the batch transform job.
- Best
Objective NotImproving A structure that keeps track of which training jobs launched by your hyperparameter tuning job are not improving model performance as evaluated against an objective function.
- Bias
Contains bias metrics for a model.
- Blue
Green Update Policy Update policy for a blue/green deployment. If this update policy is specified, SageMaker creates a new fleet during the deployment while maintaining the old fleet. SageMaker flips traffic to the new fleet according to the specified traffic routing configuration. Only one update policy should be used in the deployment configuration. If no update policy is specified, SageMaker uses a blue/green deployment strategy with all at once traffic shifting by default.
- Cache
HitResult Details on the cache hit of a pipeline execution step.
- Callback
Step Metadata Metadata about a callback step.
- Candidate
Artifact Locations The location of artifacts for an AutoML candidate job.
- Candidate
Generation Config Stores the configuration information for how model candidates are generated using an AutoML job V2.
- Candidate
Properties The properties of an AutoML candidate job.
- Canvas
AppSettings The SageMaker Canvas application settings.
- Capacity
Size Specifies the type and size of the endpoint capacity to activate for a blue/green deployment, a rolling deployment, or a rollback strategy. You can specify your batches as either instance count or the overall percentage or your fleet.
For a rollback strategy, if you don't specify the fields in this object, or if you set the
Valueto 100%, then SageMaker uses a blue/green rollback strategy and rolls all traffic back to the blue fleet.- Capacity
Size Config The configuration of the size measurements of the AMI update. Using this configuration, you can specify whether SageMaker should update your instance group by an amount or percentage of instances.
- Capture
Content Type Header Configuration specifying how to treat different headers. If no headers are specified Amazon SageMaker AI will by default base64 encode when capturing the data.
- Capture
Option Specifies data Model Monitor will capture.
- Categorical
Parameter Environment parameters you want to benchmark your load test against.
- Categorical
Parameter Range A list of categorical hyperparameters to tune.
- Categorical
Parameter Range Specification Defines the possible values for a categorical hyperparameter.
- Channel
A channel is a named input source that training algorithms can consume.
- Channel
Specification Defines a named input source, called a channel, to be used by an algorithm.
- Checkpoint
Config Contains information about the output location for managed spot training checkpoint data.
- Clarify
Check Step Metadata The container for the metadata for the ClarifyCheck step. For more information, see the topic on ClarifyCheck step in the Amazon SageMaker Developer Guide.
- Clarify
Explainer Config The configuration parameters for the SageMaker Clarify explainer.
- Clarify
Inference Config The inference configuration parameter for the model container.
- Clarify
Shap Baseline Config The configuration for the SHAP baseline (also called the background or reference dataset) of the Kernal SHAP algorithm.
-
The number of records in the baseline data determines the size of the synthetic dataset, which has an impact on latency of explainability requests. For more information, see the Synthetic data of Configure and create an endpoint.
-
ShapBaselineandShapBaselineUriare mutually exclusive parameters. One or the either is required to configure a SHAP baseline.
-
- Clarify
Shap Config The configuration for SHAP analysis using SageMaker Clarify Explainer.
- Clarify
Text Config A parameter used to configure the SageMaker Clarify explainer to treat text features as text so that explanations are provided for individual units of text. Required only for natural language processing (NLP) explainability.
- Cluster
EbsVolume Config Defines the configuration for attaching an additional Amazon Elastic Block Store (EBS) volume to each instance of the SageMaker HyperPod cluster instance group. To learn more, see SageMaker HyperPod release notes: June 20, 2024.
- Cluster
Instance Group Details Details of an instance group in a SageMaker HyperPod cluster.
- Cluster
Instance Group Specification The specifications of an instance group that you need to define.
- Cluster
Instance Placement Specifies the placement details for the node in the SageMaker HyperPod cluster, including the Availability Zone and the unique identifier (ID) of the Availability Zone.
- Cluster
Instance Status Details Details of an instance in a SageMaker HyperPod cluster.
- Cluster
Life Cycle Config The lifecycle configuration for a SageMaker HyperPod cluster.
- Cluster
Node Details Details of an instance (also called a node interchangeably) in a SageMaker HyperPod cluster.
- Cluster
Node Summary Lists a summary of the properties of an instance (also called a node interchangeably) of a SageMaker HyperPod cluster.
- Cluster
Orchestrator The type of orchestrator used for the SageMaker HyperPod cluster.
- Cluster
Orchestrator EksConfig The configuration settings for the Amazon EKS cluster used as the orchestrator for the SageMaker HyperPod cluster.
- Cluster
Scheduler Config Summary Summary of the cluster policy.
- Cluster
Summary Lists a summary of the properties of a SageMaker HyperPod cluster.
- Code
Editor AppImage Config The configuration for the file system and kernels in a SageMaker image running as a Code Editor app. The
FileSystemConfigobject is not supported.- Code
Editor AppSettings The Code Editor application settings.
For more information about Code Editor, see Get started with Code Editor in Amazon SageMaker.
- Code
Repository A Git repository that SageMaker AI automatically displays to users for cloning in the JupyterServer application.
- Code
Repository Summary Specifies summary information about a Git repository.
- Cognito
Config Use this parameter to configure your Amazon Cognito workforce. A single Cognito workforce is created using and corresponds to a single Amazon Cognito user pool.
- Cognito
Member Definition Identifies a Amazon Cognito user group. A user group can be used in on or more work teams.
- Collection
Configuration Configuration information for the Amazon SageMaker Debugger output tensor collections.
- Compilation
JobSummary A summary of a model compilation job.
- Compute
Quota Config Configuration of the compute allocation definition for an entity. This includes the resource sharing option and the setting to preempt low priority tasks.
- Compute
Quota Resource Config Configuration of the resources used for the compute allocation definition.
- Compute
Quota Summary Summary of the compute allocation definition.
- Compute
Quota Target The target entity to allocate compute resources to.
- Condition
Step Metadata Metadata for a Condition step.
- Container
Config The configuration used to run the application image container.
- Container
Definition Describes the container, as part of model definition.
- Context
Source A structure describing the source of a context.
- Context
Summary Lists a summary of the properties of a context. A context provides a logical grouping of other entities.
- Continuous
Parameter Range A list of continuous hyperparameters to tune.
- Continuous
Parameter Range Specification Defines the possible values for a continuous hyperparameter.
- Convergence
Detected A flag to indicating that automatic model tuning (AMT) has detected model convergence, defined as a lack of significant improvement (1% or less) against an objective metric.
- Custom
Image A custom SageMaker AI image. For more information, see Bring your own SageMaker AI image.
- Custom
Posix User Config Details about the POSIX identity that is used for file system operations.
- Customized
Metric Specification A customized metric.
- Data
Capture Config Configuration to control how SageMaker AI captures inference data.
- Data
Capture Config Summary The currently active data capture configuration used by your Endpoint.
- Data
Catalog Config The meta data of the Glue table which serves as data catalog for the
OfflineStore.- Data
Processing The data structure used to specify the data to be used for inference in a batch transform job and to associate the data that is relevant to the prediction results in the output. The input filter provided allows you to exclude input data that is not needed for inference in a batch transform job. The output filter provided allows you to include input data relevant to interpreting the predictions in the output from the job. For more information, see Associate Prediction Results with their Corresponding Input Records.
- Data
Quality AppSpecification Information about the container that a data quality monitoring job runs.
- Data
Quality Baseline Config Configuration for monitoring constraints and monitoring statistics. These baseline resources are compared against the results of the current job from the series of jobs scheduled to collect data periodically.
- Data
Quality JobInput The input for the data quality monitoring job. Currently endpoints are supported for input.
- Data
Source Describes the location of the channel data.
- Dataset
Definition Configuration for Dataset Definition inputs. The Dataset Definition input must specify exactly one of either
AthenaDatasetDefinitionorRedshiftDatasetDefinitiontypes.- Debug
Hook Config Configuration information for the Amazon SageMaker Debugger hook parameters, metric and tensor collections, and storage paths. To learn more about how to configure the
DebugHookConfigparameter, see Use the SageMaker and Debugger Configuration API Operations to Create, Update, and Debug Your Training Job.- Debug
Rule Configuration Configuration information for SageMaker Debugger rules for debugging. To learn more about how to configure the
DebugRuleConfigurationparameter, see Use the SageMaker and Debugger Configuration API Operations to Create, Update, and Debug Your Training Job.- Debug
Rule Evaluation Status Information about the status of the rule evaluation.
- Default
EbsStorage Settings A collection of default EBS storage settings that apply to spaces created within a domain or user profile.
- Default
Space Settings The default settings for shared spaces that users create in the domain.
SageMaker applies these settings only to shared spaces. It doesn't apply them to private spaces.
- Default
Space Storage Settings The default storage settings for a space.
- Deployed
Image Gets the Amazon EC2 Container Registry path of the docker image of the model that is hosted in this ProductionVariant.
If you used the
registry/repository\[:tag\]form to specify the image path of the primary container when you created the model hosted in thisProductionVariant, the path resolves to a path of the formregistry/repository\[@digest\]. A digest is a hash value that identifies a specific version of an image. For information about Amazon ECR paths, see Pulling an Image in the Amazon ECR User Guide.- Deployment
Config The deployment configuration for an endpoint, which contains the desired deployment strategy and rollback configurations.
- Deployment
Configuration The configuration to use when updating the AMI versions.
- Deployment
Recommendation A set of recommended deployment configurations for the model. To get more advanced recommendations, see CreateInferenceRecommendationsJob to create an inference recommendation job.
- Deployment
Stage Contains information about a stage in an edge deployment plan.
- Deployment
Stage Status Summary Contains information summarizing the deployment stage results.
- Derived
Information Information that SageMaker Neo automatically derived about the model.
- Desired
Weight AndCapacity Specifies weight and capacity values for a production variant.
- Device
Information of a particular device.
- Device
Deployment Summary Contains information summarizing device details and deployment status.
- Device
Fleet Summary Summary of the device fleet.
- Device
Selection Config Contains information about the configurations of selected devices.
- Device
Stats Status of devices.
- Device
Summary Summary of the device.
- Direct
Deploy Settings The model deployment settings for the SageMaker Canvas application.
In order to enable model deployment for Canvas, the SageMaker Domain's or user profile's Amazon Web Services IAM execution role must have the
AmazonSageMakerCanvasDirectDeployAccesspolicy attached. You can also turn on model deployment permissions through the SageMaker Domain's or user profile's settings in the SageMaker console.- Docker
Settings A collection of settings that configure the domain's Docker interaction.
- Domain
Details The domain's details.
- Domain
Settings A collection of settings that apply to the
SageMaker Domain. These settings are specified through theCreateDomainAPI call.- Domain
Settings ForUpdate A collection of
Domainconfiguration settings to update.- Drift
Check Baselines Represents the drift check baselines that can be used when the model monitor is set using the model package.
- Drift
Check Bias Represents the drift check bias baselines that can be used when the model monitor is set using the model package.
- Drift
Check Explainability Represents the drift check explainability baselines that can be used when the model monitor is set using the model package.
- Drift
Check Model Data Quality Represents the drift check data quality baselines that can be used when the model monitor is set using the model package.
- Drift
Check Model Quality Represents the drift check model quality baselines that can be used when the model monitor is set using the model package.
- Dynamic
Scaling Configuration An object with the recommended values for you to specify when creating an autoscaling policy.
- EbsStorage
Settings A collection of EBS storage settings that apply to both private and shared spaces.
- Ec2Capacity
Reservation The EC2 capacity reservations that are shared to an ML capacity reservation.
- Edge
A directed edge connecting two lineage entities.
- Edge
Deployment Config Contains information about the configuration of a deployment.
- Edge
Deployment Model Config Contains information about the configuration of a model in a deployment.
- Edge
Deployment Plan Summary Contains information summarizing an edge deployment plan.
- Edge
Deployment Status Contains information summarizing the deployment stage results.
- Edge
Model The model on the edge device.
- Edge
Model Stat Status of edge devices with this model.
- Edge
Model Summary Summary of model on edge device.
- Edge
Output Config The output configuration.
- Edge
Packaging JobSummary Summary of edge packaging job.
- Edge
Preset Deployment Output The output of a SageMaker Edge Manager deployable resource.
- EfsFile
System A file system, created by you in Amazon EFS, that you assign to a user profile or space for an Amazon SageMaker AI Domain. Permitted users can access this file system in Amazon SageMaker AI Studio.
- EfsFile
System Config The settings for assigning a custom Amazon EFS file system to a user profile or space for an Amazon SageMaker AI Domain.
- EmrServerless
Compute Config This data type is intended for use exclusively by SageMaker Canvas and cannot be used in other contexts at the moment.
Specifies the compute configuration for the EMR Serverless job.
- EmrServerless
Settings The settings for running Amazon EMR Serverless jobs in SageMaker Canvas.
- EmrSettings
The configuration parameters that specify the IAM roles assumed by the execution role of SageMaker (assumable roles) and the cluster instances or job execution environments (execution roles or runtime roles) to manage and access resources required for running Amazon EMR clusters or Amazon EMR Serverless applications.
- EmrStep
Metadata The configurations and outcomes of an Amazon EMR step execution.
- Endpoint
A hosted endpoint for real-time inference.
- Endpoint
Config Step Metadata Metadata for an endpoint configuration step.
- Endpoint
Config Summary Provides summary information for an endpoint configuration.
- Endpoint
Info Details about a customer endpoint that was compared in an Inference Recommender job.
- Endpoint
Input Input object for the endpoint
- Endpoint
Input Configuration The endpoint configuration for the load test.
- Endpoint
Metadata The metadata of the endpoint.
- Endpoint
Output Configuration The endpoint configuration made by Inference Recommender during a recommendation job.
- Endpoint
Performance The performance results from running an Inference Recommender job on an existing endpoint.
- Endpoint
Step Metadata Metadata for an endpoint step.
- Endpoint
Summary Provides summary information for an endpoint.
- Environment
Parameter A list of environment parameters suggested by the Amazon SageMaker Inference Recommender.
- Environment
Parameter Ranges Specifies the range of environment parameters
- Error
Info This is an error field object that contains the error code and the reason for an operation failure.
- Experiment
The properties of an experiment as returned by the Search API. For information about experiments, see the CreateExperiment API.
- Experiment
Config Associates a SageMaker job as a trial component with an experiment and trial. Specified when you call the following APIs:
- Experiment
Source The source of the experiment.
- Experiment
Summary A summary of the properties of an experiment. To get the complete set of properties, call the DescribeExperiment API and provide the
ExperimentName.- Explainability
Contains explainability metrics for a model.
- Explainer
Config A parameter to activate explainers.
- FSxLustre
File System A custom file system in Amazon FSx for Lustre.
- FSxLustre
File System Config The settings for assigning a custom Amazon FSx for Lustre file system to a user profile or space for an Amazon SageMaker Domain.
- Fail
Step Metadata The container for the metadata for Fail step.
- Feature
Definition A list of features. You must include
FeatureNameandFeatureType. Valid featureFeatureTypes areIntegral,FractionalandString.- Feature
Group Amazon SageMaker Feature Store stores features in a collection called Feature Group. A Feature Group can be visualized as a table which has rows, with a unique identifier for each row where each column in the table is a feature. In principle, a Feature Group is composed of features and values per features.
- Feature
Group Summary The name, ARN,
CreationTime,FeatureGroupvalues,LastUpdatedTimeandEnableOnlineStoragestatus of aFeatureGroup.- Feature
Metadata The metadata for a feature. It can either be metadata that you specify, or metadata that is updated automatically.
- Feature
Parameter A key-value pair that you specify to describe the feature.
- File
Source Contains details regarding the file source.
- File
System Config The Amazon Elastic File System storage configuration for a SageMaker AI image.
- File
System Data Source Specifies a file system data source for a channel.
- Filter
A conditional statement for a search expression that includes a resource property, a Boolean operator, and a value. Resources that match the statement are returned in the results from the Search API.
If you specify a
Value, but not anOperator, SageMaker uses the equals operator.In search, there are several property types:
- Metrics
-
To define a metric filter, enter a value using the form
"Metrics.<name>", where<name>is a metric name. For example, the following filter searches for training jobs with an"accuracy"metric greater than"0.9":{"Name": "Metrics.accuracy","Operator": "GreaterThan","Value": "0.9"} - HyperParameters
-
To define a hyperparameter filter, enter a value with the form
"HyperParameters.<name>". Decimal hyperparameter values are treated as a decimal in a comparison if the specifiedValueis also a decimal value. If the specifiedValueis an integer, the decimal hyperparameter values are treated as integers. For example, the following filter is satisfied by training jobs with a"learning_rate"hyperparameter that is less than"0.5":{"Name": "HyperParameters.learning_rate","Operator": "LessThan","Value": "0.5"} - Tags
-
To define a tag filter, enter a value with the form
Tags.<key>.
- Final
Auto MlJob Objective Metric The best candidate result from an AutoML training job.
- Final
Hyper Parameter Tuning JobObjective Metric Shows the latest objective metric emitted by a training job that was launched by a hyperparameter tuning job. You define the objective metric in the
HyperParameterTuningJobObjectiveparameter of HyperParameterTuningJobConfig.- Flow
Definition Output Config Contains information about where human output will be stored.
- Flow
Definition Summary Contains summary information about the flow definition.
- Generative
AiSettings The generative AI settings for the SageMaker Canvas application.
Configure these settings for Canvas users starting chats with generative AI foundation models. For more information, see Use generative AI with foundation models.
- GitConfig
Specifies configuration details for a Git repository in your Amazon Web Services account.
- GitConfig
ForUpdate Specifies configuration details for a Git repository when the repository is updated.
- Hidden
Sage Maker Image The SageMaker images that are hidden from the Studio user interface. You must specify the SageMaker image name and version aliases.
- Holiday
Config Attributes Stores the holiday featurization attributes applicable to each item of time-series datasets during the training of a forecasting model. This allows the model to identify patterns associated with specific holidays.
- HubAccess
Config The configuration for a private hub model reference that points to a public SageMaker JumpStart model.
For more information about private hubs, see Private curated hubs for foundation model access control in JumpStart.
- HubContent
Dependency Any dependencies related to hub content, such as scripts, model artifacts, datasets, or notebooks.
- HubContent
Info Information about hub content.
- HubInfo
Information about a hub.
- HubS3
Storage Config The Amazon S3 storage configuration of a hub.
- Human
Loop Activation Conditions Config Defines under what conditions SageMaker creates a human loop. Used within CreateFlowDefinition. See HumanLoopActivationConditionsConfig for the required format of activation conditions.
- Human
Loop Activation Config Provides information about how and under what conditions SageMaker creates a human loop. If
HumanLoopActivationConfigis not given, then all requests go to humans.- Human
Loop Config Describes the work to be performed by human workers.
- Human
Loop Request Source Container for configuring the source of human task requests.
- Human
Task Config Information required for human workers to complete a labeling task.
- Human
Task UiSummary Container for human task user interface information.
- Hyper
Parameter Algorithm Specification Specifies which training algorithm to use for training jobs that a hyperparameter tuning job launches and the metrics to monitor.
- Hyper
Parameter Specification Defines a hyperparameter to be used by an algorithm.
- Hyper
Parameter Training JobDefinition Defines the training jobs launched by a hyperparameter tuning job.
- Hyper
Parameter Training JobSummary The container for the summary information about a training job.
- Hyper
Parameter Tuning Instance Config The configuration for hyperparameter tuning resources for use in training jobs launched by the tuning job. These resources include compute instances and storage volumes. Specify one or more compute instance configurations and allocation strategies to select resources (optional).
- Hyper
Parameter Tuning JobCompletion Details A structure that contains runtime information about both current and completed hyperparameter tuning jobs.
- Hyper
Parameter Tuning JobConfig Configures a hyperparameter tuning job.
- Hyper
Parameter Tuning JobConsumed Resources The total resources consumed by your hyperparameter tuning job.
- Hyper
Parameter Tuning JobObjective Defines the objective metric for a hyperparameter tuning job. Hyperparameter tuning uses the value of this metric to evaluate the training jobs it launches, and returns the training job that results in either the highest or lowest value for this metric, depending on the value you specify for the
Typeparameter. If you want to define a custom objective metric, see Define metrics and environment variables.- Hyper
Parameter Tuning JobSearch Entity An entity returned by the SearchRecord API containing the properties of a hyperparameter tuning job.
- Hyper
Parameter Tuning JobStrategy Config The configuration for a training job launched by a hyperparameter tuning job. Choose
Bayesianfor Bayesian optimization, andRandomfor random search optimization. For more advanced use cases, useHyperband, which evaluates objective metrics for training jobs after every epoch. For more information about strategies, see How Hyperparameter Tuning Works.- Hyper
Parameter Tuning JobSummary Provides summary information about a hyperparameter tuning job.
- Hyper
Parameter Tuning JobWarm Start Config Specifies the configuration for a hyperparameter tuning job that uses one or more previous hyperparameter tuning jobs as a starting point. The results of previous tuning jobs are used to inform which combinations of hyperparameters to search over in the new tuning job.
All training jobs launched by the new hyperparameter tuning job are evaluated by using the objective metric, and the training job that performs the best is compared to the best training jobs from the parent tuning jobs. From these, the training job that performs the best as measured by the objective metric is returned as the overall best training job.
All training jobs launched by parent hyperparameter tuning jobs and the new hyperparameter tuning jobs count against the limit of training jobs for the tuning job.
- Hyper
Parameter Tuning Resource Config The configuration of resources, including compute instances and storage volumes for use in training jobs launched by hyperparameter tuning jobs.
HyperParameterTuningResourceConfigis similar toResourceConfig, but has the additionalInstanceConfigsandAllocationStrategyfields to allow for flexible instance management. Specify one or more instance types, count, and the allocation strategy for instance selection.HyperParameterTuningResourceConfigsupports the capabilities ofResourceConfigwith the exception ofKeepAlivePeriodInSeconds. Hyperparameter tuning jobs use warm pools by default, which reuse clusters between training jobs.- Hyperband
Strategy Config The configuration for
Hyperband, a multi-fidelity based hyperparameter tuning strategy.Hyperbanduses the final and intermediate results of a training job to dynamically allocate resources to utilized hyperparameter configurations while automatically stopping under-performing configurations. This parameter should be provided only ifHyperbandis selected as theStrategyConfigunder theHyperParameterTuningJobConfigAPI.- IamIdentity
The IAM Identity details associated with the user. These details are associated with model package groups, model packages and project entities only.
- IamPolicy
Constraints Use this parameter to specify a supported global condition key that is added to the IAM policy.
- Identity
ProviderO Auth Setting The Amazon SageMaker Canvas application setting where you configure OAuth for connecting to an external data source, such as Snowflake.
- Idle
Settings Settings related to idle shutdown of Studio applications.
- Image
A SageMaker AI image. A SageMaker AI image represents a set of container images that are derived from a common base container image. Each of these container images is represented by a SageMaker AI
ImageVersion.- Image
Classification JobConfig The collection of settings used by an AutoML job V2 for the image classification problem type.
- Image
Config Specifies whether the model container is in Amazon ECR or a private Docker registry accessible from your Amazon Virtual Private Cloud (VPC).
- Image
Version A version of a SageMaker AI
Image. A version represents an existing container image.- Inference
Component Capacity Size Specifies the type and size of the endpoint capacity to activate for a rolling deployment or a rollback strategy. You can specify your batches as either of the following:
-
A count of inference component copies
-
The overall percentage or your fleet
For a rollback strategy, if you don't specify the fields in this object, or if you set the
Valueparameter to 100%, then SageMaker AI uses a blue/green rollback strategy and rolls all traffic back to the blue fleet.-
- Inference
Component Compute Resource Requirements Defines the compute resources to allocate to run a model, plus any adapter models, that you assign to an inference component. These resources include CPU cores, accelerators, and memory.
- Inference
Component Container Specification Defines a container that provides the runtime environment for a model that you deploy with an inference component.
- Inference
Component Container Specification Summary Details about the resources that are deployed with this inference component.
- Inference
Component Deployment Config The deployment configuration for an endpoint that hosts inference components. The configuration includes the desired deployment strategy and rollback settings.
- Inference
Component Rolling Update Policy Specifies a rolling deployment strategy for updating a SageMaker AI inference component.
- Inference
Component Runtime Config Runtime settings for a model that is deployed with an inference component.
- Inference
Component Runtime Config Summary Details about the runtime settings for the model that is deployed with the inference component.
- Inference
Component Specification Details about the resources to deploy with this inference component, including the model, container, and compute resources.
- Inference
Component Specification Summary Details about the resources that are deployed with this inference component.
- Inference
Component Startup Parameters Settings that take effect while the model container starts up.
- Inference
Component Summary A summary of the properties of an inference component.
- Inference
Execution Config Specifies details about how containers in a multi-container endpoint are run.
- Inference
Experiment Data Storage Config The Amazon S3 location and configuration for storing inference request and response data.
- Inference
Experiment Schedule The start and end times of an inference experiment.
The maximum duration that you can set for an inference experiment is 30 days.
- Inference
Experiment Summary Lists a summary of properties of an inference experiment.
- Inference
HubAccess Config Configuration information specifying which hub contents have accessible deployment options.
- Inference
Metrics The metrics for an existing endpoint compared in an Inference Recommender job.
- Inference
Recommendation A list of recommendations made by Amazon SageMaker Inference Recommender.
- Inference
Recommendations Job A structure that contains a list of recommendation jobs.
- Inference
Recommendations JobStep A returned array object for the
Stepsresponse field in the ListInferenceRecommendationsJobSteps API command.- Inference
Specification Defines how to perform inference generation after a training job is run.
- Infra
Check Config Configuration information for the infrastructure health check of a training job. A SageMaker-provided health check tests the health of instance hardware and cluster network connectivity.
- Input
Config Contains information about the location of input model artifacts, the name and shape of the expected data inputs, and the framework in which the model was trained.
- Instance
Group Defines an instance group for heterogeneous cluster training. When requesting a training job using the CreateTrainingJob API, you can configure multiple instance groups .
- Instance
Metadata Service Configuration Information on the IMDS configuration of the notebook instance
- Integer
Parameter Range For a hyperparameter of the integer type, specifies the range that a hyperparameter tuning job searches.
- Integer
Parameter Range Specification Defines the possible values for an integer hyperparameter.
- Jupyter
LabApp Image Config The configuration for the file system and kernels in a SageMaker AI image running as a JupyterLab app. The
FileSystemConfigobject is not supported.- Jupyter
LabApp Settings The settings for the JupyterLab application.
- Jupyter
Server AppSettings The JupyterServer app settings.
- Kendra
Settings The Amazon SageMaker Canvas application setting where you configure document querying.
- Kernel
Gateway AppSettings The KernelGateway app settings.
- Kernel
Gateway Image Config The configuration for the file system and kernels in a SageMaker AI image running as a KernelGateway app.
- Kernel
Spec The specification of a Jupyter kernel.
- Label
Counters Provides a breakdown of the number of objects labeled.
- Label
Counters ForWorkteam Provides counts for human-labeled tasks in the labeling job.
- Labeling
JobAlgorithms Config Provides configuration information for auto-labeling of your data objects. A
LabelingJobAlgorithmsConfigobject must be supplied in order to use auto-labeling.- Labeling
JobData Attributes Attributes of the data specified by the customer. Use these to describe the data to be labeled.
- Labeling
JobData Source Provides information about the location of input data.
You must specify at least one of the following:
S3DataSourceorSnsDataSource.Use
SnsDataSourceto specify an SNS input topic for a streaming labeling job. If you do not specify and SNS input topic ARN, Ground Truth will create a one-time labeling job.Use
S3DataSourceto specify an input manifest file for both streaming and one-time labeling jobs. Adding anS3DataSourceis optional if you useSnsDataSourceto create a streaming labeling job.- Labeling
JobFor Workteam Summary Provides summary information for a work team.
- Labeling
JobInput Config Input configuration information for a labeling job.
- Labeling
JobOutput Specifies the location of the output produced by the labeling job.
- Labeling
JobOutput Config Output configuration information for a labeling job.
- Labeling
JobResource Config Configure encryption on the storage volume attached to the ML compute instance used to run automated data labeling model training and inference.
- Labeling
JobS3 Data Source The Amazon S3 location of the input data objects.
- Labeling
JobSns Data Source An Amazon SNS data source used for streaming labeling jobs.
- Labeling
JobStopping Conditions A set of conditions for stopping a labeling job. If any of the conditions are met, the job is automatically stopped. You can use these conditions to control the cost of data labeling.
Labeling jobs fail after 30 days with an appropriate client error message.
- Labeling
JobSummary Provides summary information about a labeling job.
- Lambda
Step Metadata Metadata for a Lambda step.
- Last
Update Status A value that indicates whether the update was successful.
- Lineage
Group Summary Lists a summary of the properties of a lineage group. A lineage group provides a group of shareable lineage entity resources.
- Member
Definition Defines an Amazon Cognito or your own OIDC IdP user group that is part of a work team.
- Metadata
Properties Metadata properties of the tracking entity, trial, or trial component.
- Metric
Data The name, value, and date and time of a metric that was emitted to Amazon CloudWatch.
- Metric
Datum Information about the metric for a candidate produced by an AutoML job.
- Metric
Definition Specifies a metric that the training algorithm writes to
stderrorstdout. You can view these logs to understand how your training job performs and check for any errors encountered during training. SageMaker hyperparameter tuning captures all defined metrics. Specify one of the defined metrics to use as an objective metric using the TuningObjective parameter in theHyperParameterTrainingJobDefinitionAPI to evaluate job performance during hyperparameter tuning.- Metrics
Source Details about the metrics source.
- Model
The properties of a model as returned by the Search API.
- Model
Access Config The access configuration file to control access to the ML model. You can explicitly accept the model end-user license agreement (EULA) within the
ModelAccessConfig.-
If you are a Jumpstart user, see the End-user license agreements section for more details on accepting the EULA.
-
If you are an AutoML user, see the Optional Parameters section of Create an AutoML job to fine-tune text generation models using the API for details on How to set the EULA acceptance when fine-tuning a model using the AutoML API.
-
- Model
Artifacts Provides information about the location that is configured for storing model artifacts.
Model artifacts are outputs that result from training a model. They typically consist of trained parameters, a model definition that describes how to compute inferences, and other metadata. A SageMaker container stores your trained model artifacts in the
/opt/ml/modeldirectory. After training has completed, by default, these artifacts are uploaded to your Amazon S3 bucket as compressed files.- Model
Bias AppSpecification Docker container image configuration object for the model bias job.
- Model
Bias Baseline Config The configuration for a baseline model bias job.
- Model
Bias JobInput Inputs for the model bias job.
- Model
Card An Amazon SageMaker Model Card.
- Model
Card Export Artifacts The artifacts of the model card export job.
- Model
Card Export JobSummary The summary of the Amazon SageMaker Model Card export job.
- Model
Card Export Output Config Configure the export output details for an Amazon SageMaker Model Card.
- Model
Card Security Config Configure the security settings to protect model card data.
- Model
Card Summary A summary of the model card.
- Model
Card Version Summary A summary of a specific version of the model card.
- Model
Client Config Configures the timeout and maximum number of retries for processing a transform job invocation.
- Model
Compilation Config Settings for the model compilation technique that's applied by a model optimization job.
- Model
Configuration Defines the model configuration. Includes the specification name and environment parameters.
- Model
Dashboard Endpoint An endpoint that hosts a model displayed in the Amazon SageMaker Model Dashboard.
- Model
Dashboard Indicator Action An alert action taken to light up an icon on the Amazon SageMaker Model Dashboard when an alert goes into
InAlertstatus.- Model
Dashboard Model A model displayed in the Amazon SageMaker Model Dashboard.
- Model
Dashboard Model Card The model card for a model displayed in the Amazon SageMaker Model Dashboard.
- Model
Dashboard Monitoring Schedule A monitoring schedule for a model displayed in the Amazon SageMaker Model Dashboard.
- Model
Data Quality Data quality constraints and statistics for a model.
- Model
Data Source Specifies the location of ML model data to deploy. If specified, you must specify one and only one of the available data sources.
- Model
Deploy Config Specifies how to generate the endpoint name for an automatic one-click Autopilot model deployment.
- Model
Deploy Result Provides information about the endpoint of the model deployment.
- Model
Digests Provides information to verify the integrity of stored model artifacts.
- Model
Explainability AppSpecification Docker container image configuration object for the model explainability job.
- Model
Explainability Baseline Config The configuration for a baseline model explainability job.
- Model
Explainability JobInput Inputs for the model explainability job.
- Model
Infrastructure Config The configuration for the infrastructure that the model will be deployed to.
- Model
Input Input object for the model.
- Model
Latency Threshold The model latency threshold.
- Model
Life Cycle A structure describing the current state of the model in its life cycle.
- Model
Metadata Filter Part of the search expression. You can specify the name and value (domain, task, framework, framework version, task, and model).
- Model
Metadata Search Expression One or more filters that searches for the specified resource or resources in a search. All resource objects that satisfy the expression's condition are included in the search results
- Model
Metadata Summary A summary of the model metadata.
- Model
Metrics Contains metrics captured from a model.
- Model
Package A container for your trained model that can be deployed for SageMaker inference. This can include inference code, artifacts, and metadata. The model package type can be one of the following.
-
Versioned model: A part of a model package group in Model Registry.
-
Unversioned model: Not part of a model package group and used in Amazon Web Services Marketplace.
For more information, see
CreateModelPackage.-
- Model
Package Container Definition Describes the Docker container for the model package.
- Model
Package Group A group of versioned models in the Model Registry.
- Model
Package Group Summary Summary information about a model group.
- Model
Package Model Card The model card associated with the model package. Since
ModelPackageModelCardis tied to a model package, it is a specific usage of a model card and its schema is simplified compared to the schema ofModelCard. TheModelPackageModelCardschema does not includemodel_package_details, andmodel_overviewis composed of themodel_creatorandmodel_artifactproperties. For more information about the model package model card schema, see Model package model card schema. For more information about the model card associated with the model package, see View the Details of a Model Version.- Model
Package Security Config An optional Key Management Service key to encrypt, decrypt, and re-encrypt model package information for regulated workloads with highly sensitive data.
- Model
Package Status Details Specifies the validation and image scan statuses of the model package.
- Model
Package Status Item Represents the overall status of a model package.
- Model
Package Summary Provides summary information about a model package.
- Model
Package Validation Profile Contains data, such as the inputs and targeted instance types that are used in the process of validating the model package.
The data provided in the validation profile is made available to your buyers on Amazon Web Services Marketplace.
- Model
Package Validation Specification Specifies batch transform jobs that SageMaker runs to validate your model package.
- Model
Quality Model quality statistics and constraints.
- Model
Quality AppSpecification Container image configuration object for the monitoring job.
- Model
Quality Baseline Config Configuration for monitoring constraints and monitoring statistics. These baseline resources are compared against the results of the current job from the series of jobs scheduled to collect data periodically.
- Model
Quality JobInput The input for the model quality monitoring job. Currently endpoints are supported for input for model quality monitoring jobs.
- Model
Quantization Config Settings for the model quantization technique that's applied by a model optimization job.
- Model
Register Settings The model registry settings for the SageMaker Canvas application.
- Model
Sharding Config Settings for the model sharding technique that's applied by a model optimization job.
- Model
Step Metadata Metadata for Model steps.
- Model
Summary Provides summary information about a model.
- Model
Variant Config Contains information about the deployment options of a model.
- Model
Variant Config Summary Summary of the deployment configuration of a model.
- Monitoring
Alert Actions A list of alert actions taken in response to an alert going into
InAlertstatus.- Monitoring
Alert History Summary Provides summary information of an alert's history.
- Monitoring
Alert Summary Provides summary information about a monitor alert.
- Monitoring
AppSpecification Container image configuration object for the monitoring job.
- Monitoring
Baseline Config Configuration for monitoring constraints and monitoring statistics. These baseline resources are compared against the results of the current job from the series of jobs scheduled to collect data periodically.
- Monitoring
Cluster Config Configuration for the cluster used to run model monitoring jobs.
- Monitoring
Constraints Resource The constraints resource for a monitoring job.
- Monitoring
CsvDataset Format Represents the CSV dataset format used when running a monitoring job.
- Monitoring
Dataset Format Represents the dataset format used when running a monitoring job.
- Monitoring
Execution Summary Summary of information about the last monitoring job to run.
- Monitoring
Ground Truth S3Input The ground truth labels for the dataset used for the monitoring job.
- Monitoring
Input The inputs for a monitoring job.
- Monitoring
JobDefinition Defines the monitoring job.
- Monitoring
JobDefinition Summary Summary information about a monitoring job.
- Monitoring
Json Dataset Format Represents the JSON dataset format used when running a monitoring job.
- Monitoring
Network Config The networking configuration for the monitoring job.
- Monitoring
Output The output object for a monitoring job.
- Monitoring
Output Config The output configuration for monitoring jobs.
- Monitoring
Parquet Dataset Format Represents the Parquet dataset format used when running a monitoring job.
- Monitoring
Resources Identifies the resources to deploy for a monitoring job.
- Monitoring
S3Output Information about where and how you want to store the results of a monitoring job.
- Monitoring
Schedule A schedule for a model monitoring job. For information about model monitor, see Amazon SageMaker Model Monitor.
- Monitoring
Schedule Config Configures the monitoring schedule and defines the monitoring job.
- Monitoring
Schedule Summary Summarizes the monitoring schedule.
- Monitoring
Statistics Resource The statistics resource for a monitoring job.
- Monitoring
Stopping Condition A time limit for how long the monitoring job is allowed to run before stopping.
- Multi
Model Config Specifies additional configuration for hosting multi-model endpoints.
- NeoVpc
Config The VpcConfig configuration object that specifies the VPC that you want the compilation jobs to connect to. For more information on controlling access to your Amazon S3 buckets used for compilation job, see Give Amazon SageMaker AI Compilation Jobs Access to Resources in Your Amazon VPC.
- Nested
Filters A list of nested Filter objects. A resource must satisfy the conditions of all filters to be included in the results returned from the Search API.
For example, to filter on a training job's
InputDataConfigproperty with a specific channel name andS3Uriprefix, define the following filters:-
'{Name:"InputDataConfig.ChannelName", "Operator":"Equals", "Value":"train"}', -
'{Name:"InputDataConfig.DataSource.S3DataSource.S3Uri", "Operator":"Contains", "Value":"mybucket/catdata"}'
-
- Network
Config Networking options for a job, such as network traffic encryption between containers, whether to allow inbound and outbound network calls to and from containers, and the VPC subnets and security groups to use for VPC-enabled jobs.
- Notebook
Instance Lifecycle Config Summary Provides a summary of a notebook instance lifecycle configuration.
- Notebook
Instance Lifecycle Hook Contains the notebook instance lifecycle configuration script.
Each lifecycle configuration script has a limit of 16384 characters.
The value of the
$PATHenvironment variable that is available to both scripts is/sbin:bin:/usr/sbin:/usr/bin.View Amazon CloudWatch Logs for notebook instance lifecycle configurations in log group
/aws/sagemaker/NotebookInstancesin log stream\[notebook-instance-name\]/\[LifecycleConfigHook\].Lifecycle configuration scripts cannot run for longer than 5 minutes. If a script runs for longer than 5 minutes, it fails and the notebook instance is not created or started.
For information about notebook instance lifestyle configurations, see Step 2.1: (Optional) Customize a Notebook Instance.
- Notebook
Instance Summary Provides summary information for an SageMaker AI notebook instance.
- Notification
Configuration Configures Amazon SNS notifications of available or expiring work items for work teams.
- Objective
Status Counters Specifies the number of training jobs that this hyperparameter tuning job launched, categorized by the status of their objective metric. The objective metric status shows whether the final objective metric for the training job has been evaluated by the tuning job and used in the hyperparameter tuning process.
- Offline
Store Config The configuration of an
OfflineStore.Provide an
OfflineStoreConfigin a request toCreateFeatureGroupto create anOfflineStore.To encrypt an
OfflineStoreusing at rest data encryption, specify Amazon Web Services Key Management Service (KMS) key ID, orKMSKeyId, inS3StorageConfig.- Offline
Store Status The status of
OfflineStore.- Oidc
Config Use this parameter to configure your OIDC Identity Provider (IdP).
- Oidc
Config ForResponse Your OIDC IdP workforce configuration.
- Oidc
Member Definition A list of user groups that exist in your OIDC Identity Provider (IdP). One to ten groups can be used to create a single private work team. When you add a user group to the list of
Groups, you can add that user group to one or more private work teams. If you add a user group to a private work team, all workers in that user group are added to the work team.- Online
Store Config Use this to specify the Amazon Web Services Key Management Service (KMS) Key ID, or
KMSKeyId, for at rest data encryption. You can turnOnlineStoreon or off by specifying theEnableOnlineStoreflag at General Assembly.The default value is
False.- Online
Store Config Update Updates the feature group online store configuration.
- Online
Store Security Config The security configuration for
OnlineStore.- Optimization
JobModel Source The location of the source model to optimize with an optimization job.
- Optimization
JobModel Source S3 The Amazon S3 location of a source model to optimize with an optimization job.
- Optimization
JobOutput Config Details for where to store the optimized model that you create with the optimization job.
- Optimization
JobSummary Summarizes an optimization job by providing some of its key properties.
- Optimization
Model Access Config The access configuration settings for the source ML model for an optimization job, where you can accept the model end-user license agreement (EULA).
- Optimization
Output Output values produced by an optimization job.
- Optimization
VpcConfig A VPC in Amazon VPC that's accessible to an optimized that you create with an optimization job. You can control access to and from your resources by configuring a VPC. For more information, see Give SageMaker Access to Resources in your Amazon VPC.
- Output
Config Contains information about the output location for the compiled model and the target device that the model runs on.
TargetDeviceandTargetPlatformare mutually exclusive, so you need to choose one between the two to specify your target device or platform. If you cannot find your device you want to use from theTargetDevicelist, useTargetPlatformto describe the platform of your edge device andCompilerOptionsif there are specific settings that are required or recommended to use for particular TargetPlatform.- Output
Data Config Provides information about how to store model training results (model artifacts).
- Output
Parameter An output parameter of a pipeline step.
- Ownership
Settings The collection of ownership settings for a space.
- Ownership
Settings Summary Specifies summary information about the ownership settings.
- Parallelism
Configuration Configuration that controls the parallelism of the pipeline. By default, the parallelism configuration specified applies to all executions of the pipeline unless overridden.
- Parameter
Assigns a value to a named Pipeline parameter.
- Parameter
Range Defines the possible values for categorical, continuous, and integer hyperparameters to be used by an algorithm.
- Parameter
Ranges Specifies ranges of integer, continuous, and categorical hyperparameters that a hyperparameter tuning job searches. The hyperparameter tuning job launches training jobs with hyperparameter values within these ranges to find the combination of values that result in the training job with the best performance as measured by the objective metric of the hyperparameter tuning job.
The maximum number of items specified for
Array Membersrefers to the maximum number of hyperparameters for each range and also the maximum for the hyperparameter tuning job itself. That is, the sum of the number of hyperparameters for all the ranges can't exceed the maximum number specified.- Parent
The trial that a trial component is associated with and the experiment the trial is part of. A component might not be associated with a trial. A component can be associated with multiple trials.
- Parent
Hyper Parameter Tuning Job A previously completed or stopped hyperparameter tuning job to be used as a starting point for a new hyperparameter tuning job.
- Partner
AppConfig Configuration settings for the SageMaker Partner AI App.
- Partner
AppMaintenance Config Maintenance configuration settings for the SageMaker Partner AI App.
- Partner
AppSummary A subset of information related to a SageMaker Partner AI App. This information is used as part of the
ListPartnerAppsAPI response.- Pending
Deployment Summary The summary of an in-progress deployment when an endpoint is creating or updating with a new endpoint configuration.
- Pending
Production Variant Summary The production variant summary for a deployment when an endpoint is creating or updating with the CreateEndpoint or UpdateEndpoint operations. Describes the
VariantStatus, weight and capacity for a production variant associated with an endpoint.- Phase
Defines the traffic pattern.
- Pipeline
A SageMaker Model Building Pipeline instance.
- Pipeline
Definition S3Location The location of the pipeline definition stored in Amazon S3.
- Pipeline
Execution An execution of a pipeline.
- Pipeline
Execution Step An execution of a step in a pipeline.
- Pipeline
Execution Step Metadata Metadata for a step execution.
- Pipeline
Execution Summary A pipeline execution summary.
- Pipeline
Experiment Config Specifies the names of the experiment and trial created by a pipeline.
- Pipeline
Summary A summary of a pipeline.
- Predefined
Metric Specification A specification for a predefined metric.
- Priority
Class Priority class configuration. When included in
PriorityClasses, these class configurations define how tasks are queued.- Processing
Cluster Config Configuration for the cluster used to run a processing job.
- Processing
Feature Store Output Configuration for processing job outputs in Amazon SageMaker Feature Store.
- Processing
Input The inputs for a processing job. The processing input must specify exactly one of either
S3InputorDatasetDefinitiontypes.- Processing
Job An Amazon SageMaker processing job that is used to analyze data and evaluate models. For more information, see Process Data and Evaluate Models.
- Processing
JobStep Metadata Metadata for a processing job step.
- Processing
JobSummary Summary of information about a processing job.
- Processing
Output Describes the results of a processing job. The processing output must specify exactly one of either
S3OutputorFeatureStoreOutputtypes.- Processing
Output Config Configuration for uploading output from the processing container.
- Processing
Resources Identifies the resources, ML compute instances, and ML storage volumes to deploy for a processing job. In distributed training, you specify more than one instance.
- Processing
S3Input Configuration for downloading input data from Amazon S3 into the processing container.
- Processing
S3Output Configuration for uploading output data to Amazon S3 from the processing container.
- Processing
Stopping Condition Configures conditions under which the processing job should be stopped, such as how long the processing job has been running. After the condition is met, the processing job is stopped.
- Production
Variant Identifies a model that you want to host and the resources chosen to deploy for hosting it. If you are deploying multiple models, tell SageMaker how to distribute traffic among the models by specifying variant weights. For more information on production variants, check Production variants.
- Production
Variant Capacity Reservation Config Settings for the capacity reservation for the compute instances that SageMaker AI reserves for an endpoint.
- Production
Variant Capacity Reservation Summary Details about an ML capacity reservation.
- Production
Variant Core Dump Config Specifies configuration for a core dump from the model container when the process crashes.
- Production
Variant Managed Instance Scaling Settings that control the range in the number of instances that the endpoint provisions as it scales up or down to accommodate traffic.
- Production
Variant Routing Config Settings that control how the endpoint routes incoming traffic to the instances that the endpoint hosts.
- Production
Variant Serverless Config Specifies the serverless configuration for an endpoint variant.
- Production
Variant Serverless Update Config Specifies the serverless update concurrency configuration for an endpoint variant.
- Production
Variant Status Describes the status of the production variant.
- Production
Variant Summary Describes weight and capacities for a production variant associated with an endpoint. If you sent a request to the
UpdateEndpointWeightsAndCapacitiesAPI and the endpoint status isUpdating, you get different desired and current values.- Profiler
Config Configuration information for Amazon SageMaker Debugger system monitoring, framework profiling, and storage paths.
- Profiler
Config ForUpdate Configuration information for updating the Amazon SageMaker Debugger profile parameters, system and framework metrics configurations, and storage paths.
- Profiler
Rule Configuration Configuration information for profiling rules.
- Profiler
Rule Evaluation Status Information about the status of the rule evaluation.
- Project
The properties of a project as returned by the Search API.
- Project
Summary Information about a project.
- Property
Name Query Part of the
SuggestionQuerytype. Specifies a hint for retrieving property names that begin with the specified text.- Property
Name Suggestion A property name returned from a
GetSearchSuggestionscall that specifies a value in thePropertyNameQueryfield.- Provisioning
Parameter A key value pair used when you provision a project as a service catalog product. For information, see What is Amazon Web Services Service Catalog.
- Public
Workforce Task Price Defines the amount of money paid to an Amazon Mechanical Turk worker for each task performed.
Use one of the following prices for bounding box tasks. Prices are in US dollars and should be based on the complexity of the task; the longer it takes in your initial testing, the more you should offer.
-
0.036
-
0.048
-
0.060
-
0.072
-
0.120
-
0.240
-
0.360
-
0.480
-
0.600
-
0.720
-
0.840
-
0.960
-
1.080
-
1.200
Use one of the following prices for image classification, text classification, and custom tasks. Prices are in US dollars.
-
0.012
-
0.024
-
0.036
-
0.048
-
0.060
-
0.072
-
0.120
-
0.240
-
0.360
-
0.480
-
0.600
-
0.720
-
0.840
-
0.960
-
1.080
-
1.200
Use one of the following prices for semantic segmentation tasks. Prices are in US dollars.
-
0.840
-
0.960
-
1.080
-
1.200
Use one of the following prices for Textract AnalyzeDocument Important Form Key Amazon Augmented AI review tasks. Prices are in US dollars.
-
2.400
-
2.280
-
2.160
-
2.040
-
1.920
-
1.800
-
1.680
-
1.560
-
1.440
-
1.320
-
1.200
-
1.080
-
0.960
-
0.840
-
0.720
-
0.600
-
0.480
-
0.360
-
0.240
-
0.120
-
0.072
-
0.060
-
0.048
-
0.036
-
0.024
-
0.012
Use one of the following prices for Rekognition DetectModerationLabels Amazon Augmented AI review tasks. Prices are in US dollars.
-
1.200
-
1.080
-
0.960
-
0.840
-
0.720
-
0.600
-
0.480
-
0.360
-
0.240
-
0.120
-
0.072
-
0.060
-
0.048
-
0.036
-
0.024
-
0.012
Use one of the following prices for Amazon Augmented AI custom human review tasks. Prices are in US dollars.
-
1.200
-
1.080
-
0.960
-
0.840
-
0.720
-
0.600
-
0.480
-
0.360
-
0.240
-
0.120
-
0.072
-
0.060
-
0.048
-
0.036
-
0.024
-
0.012
-
- Quality
Check Step Metadata Container for the metadata for a Quality check step. For more information, see the topic on QualityCheck step in the Amazon SageMaker Developer Guide.
- Query
Filters A set of filters to narrow the set of lineage entities connected to the
StartArn(s) returned by theQueryLineageAPI action.- RSession
AppSettings A collection of settings that apply to an
RSessionGatewayapp.- RStudio
Server ProApp Settings A collection of settings that configure user interaction with the
RStudioServerProapp.- RStudio
Server ProDomain Settings A collection of settings that configure the
RStudioServerProDomain-level app.- RStudio
Server ProDomain Settings ForUpdate A collection of settings that update the current configuration for the
RStudioServerProDomain-level app.- Real
Time Inference Config The infrastructure configuration for deploying the model to a real-time inference endpoint.
- Real
Time Inference Recommendation The recommended configuration to use for Real-Time Inference.
- Recommendation
JobCompiled Output Config Provides information about the output configuration for the compiled model.
- Recommendation
JobContainer Config Specifies mandatory fields for running an Inference Recommender job directly in the CreateInferenceRecommendationsJob API. The fields specified in
ContainerConfigoverride the corresponding fields in the model package. UseContainerConfigif you want to specify these fields for the recommendation job but don't want to edit them in your model package.- Recommendation
JobInference Benchmark The details for a specific benchmark from an Inference Recommender job.
- Recommendation
JobInput Config The input configuration of the recommendation job.
- Recommendation
JobOutput Config Provides information about the output configuration for the compiled model.
- Recommendation
JobPayload Config The configuration for the payload for a recommendation job.
- Recommendation
JobResource Limit Specifies the maximum number of jobs that can run in parallel and the maximum number of jobs that can run.
- Recommendation
JobStopping Conditions Specifies conditions for stopping a job. When a job reaches a stopping condition limit, SageMaker ends the job.
- Recommendation
JobVpc Config Inference Recommender provisions SageMaker endpoints with access to VPC in the inference recommendation job.
- Recommendation
Metrics The metrics of recommendations.
- Redshift
Dataset Definition Configuration for Redshift Dataset Definition input.
- Register
Model Step Metadata Metadata for a register model job step.
- Remote
Debug Config Configuration for remote debugging for the CreateTrainingJob API. To learn more about the remote debugging functionality of SageMaker, see Access a training container through Amazon Web Services Systems Manager (SSM) for remote debugging.
- Remote
Debug Config ForUpdate Configuration for remote debugging for the UpdateTrainingJob API. To learn more about the remote debugging functionality of SageMaker, see Access a training container through Amazon Web Services Systems Manager (SSM) for remote debugging.
- Renderable
Task Contains input values for a task.
- Rendering
Error A description of an error that occurred while rendering the template.
- Repository
Auth Config Specifies an authentication configuration for the private docker registry where your model image is hosted. Specify a value for this property only if you specified
Vpcas the value for theRepositoryAccessModefield of theImageConfigobject that you passed to a call toCreateModeland the private Docker registry where the model image is hosted requires authentication.- Reserved
Capacity Offering Details about a reserved capacity offering for a training plan offering.
For more information about how to reserve GPU capacity for your SageMaker HyperPod clusters using Amazon SageMaker Training Plan, see
CreateTrainingPlan.- Reserved
Capacity Summary Details of a reserved capacity for the training plan.
For more information about how to reserve GPU capacity for your SageMaker HyperPod clusters using Amazon SageMaker Training Plan, see
CreateTrainingPlan.- Resolved
Attributes The resolved attributes.
- Resource
Catalog A resource catalog containing all of the resources of a specific resource type within a resource owner account. For an example on sharing the Amazon SageMaker Feature Store
DefaultFeatureGroupCatalog, see Share Amazon SageMaker Catalog resource type in the Amazon SageMaker Developer Guide.- Resource
Config Describes the resources, including machine learning (ML) compute instances and ML storage volumes, to use for model training.
- Resource
Config ForUpdate The
ResourceConfigto updateKeepAlivePeriodInSeconds. Other fields in theResourceConfigcannot be updated.- Resource
Limits Specifies the maximum number of training jobs and parallel training jobs that a hyperparameter tuning job can launch.
- Resource
Sharing Config Resource sharing configuration.
- Resource
Spec Specifies the ARN's of a SageMaker AI image and SageMaker AI image version, and the instance type that the version runs on.
When both
SageMakerImageVersionArnandSageMakerImageArnare passed,SageMakerImageVersionArnis used. Any updates toSageMakerImageArnwill not take effect ifSageMakerImageVersionArnalready exists in theResourceSpecbecauseSageMakerImageVersionArnalways takes precedence. To clear the value set forSageMakerImageVersionArn, passNoneas the value.- Retention
Policy The retention policy for data stored on an Amazon Elastic File System volume.
- Retry
Strategy The retry strategy to use when a training job fails due to an
InternalServerError.RetryStrategyis specified as part of theCreateTrainingJobandCreateHyperParameterTuningJobrequests. You can add theStoppingConditionparameter to the request to limit the training time for the complete job.- Rolling
Deployment Policy The configurations that SageMaker uses when updating the AMI versions.
- Rolling
Update Policy Specifies a rolling deployment strategy for updating a SageMaker endpoint.
- S3Data
Source Describes the S3 data source.
Your input bucket must be in the same Amazon Web Services region as your training job.
- S3Model
Data Source Specifies the S3 location of ML model data to deploy.
- S3Presign
This object defines the access restrictions to Amazon S3 resources that are included in custom worker task templates using the Liquid filter,
grant_read_access.To learn more about how custom templates are created, see Create custom worker task templates.
- S3Storage
Config The Amazon Simple Storage (Amazon S3) location and security configuration for
OfflineStore.- Scaling
Policy Metric The metric for a scaling policy.
- Scaling
Policy Objective An object where you specify the anticipated traffic pattern for an endpoint.
- Schedule
Config Configuration details about the monitoring schedule.
- Scheduled
Update Config The configuration object of the schedule that SageMaker follows when updating the AMI.
- Scheduler
Config Cluster policy configuration. This policy is used for task prioritization and fair-share allocation. This helps prioritize critical workloads and distributes idle compute across entities.
- Search
Expression A multi-expression that searches for the specified resource or resources in a search. All resource objects that satisfy the expression's condition are included in the search results. You must specify at least one subexpression, filter, or nested filter. A
SearchExpressioncan contain up to twenty elements.A
SearchExpressioncontains the following components:-
A list of
Filterobjects. Each filter defines a simple Boolean expression comprised of a resource property name, Boolean operator, and value. -
A list of
NestedFilterobjects. Each nested filter defines a list of Boolean expressions using a list of resource properties. A nested filter is satisfied if a single object in the list satisfies all Boolean expressions. -
A list of
SearchExpressionobjects. A search expression object can be nested in a list of search expression objects. -
A Boolean operator:
AndorOr.
-
- Search
Record A single resource returned as part of the Search API response.
- Secondary
Status Transition An array element of
SecondaryStatusTransitionsfor DescribeTrainingJob. It provides additional details about a status that the training job has transitioned through. A training job can be in one of several states, for example, starting, downloading, training, or uploading. Within each state, there are a number of intermediate states. For example, within the starting state, SageMaker could be starting the training job or launching the ML instances. These transitional states are referred to as the job's secondary status.- Selected
Step A step selected to run in selective execution mode.
- Selective
Execution Config The selective execution configuration applied to the pipeline run.
- Selective
Execution Result The ARN from an execution of the current pipeline.
- Service
Catalog Provisioned Product Details Details of a provisioned service catalog product. For information about service catalog, see What is Amazon Web Services Service Catalog.
- Service
Catalog Provisioning Details Details that you specify to provision a service catalog product. For information about service catalog, see What is Amazon Web Services Service Catalog.
- Service
Catalog Provisioning Update Details Details that you specify to provision a service catalog product. For information about service catalog, see What is Amazon Web Services Service Catalog.
- Session
Chaining Config Contains information about attribute-based access control (ABAC) for a training job. The session chaining configuration uses Amazon Security Token Service (STS) for your training job to request temporary, limited-privilege credentials to tenants. For more information, see Attribute-based access control (ABAC) for multi-tenancy training.
- Shadow
Mode Config The configuration of
ShadowModeinference experiment type, which specifies a production variant to take all the inference requests, and a shadow variant to which Amazon SageMaker replicates a percentage of the inference requests. For the shadow variant it also specifies the percentage of requests that Amazon SageMaker replicates.- Shadow
Model Variant Config The name and sampling percentage of a shadow variant.
- Sharing
Settings Specifies options for sharing Amazon SageMaker AI Studio notebooks. These settings are specified as part of
DefaultUserSettingswhen theCreateDomainAPI is called, and as part ofUserSettingswhen theCreateUserProfileAPI is called. WhenSharingSettingsis not specified, notebook sharing isn't allowed.- Shuffle
Config A configuration for a shuffle option for input data in a channel. If you use
S3PrefixforS3DataType, the results of the S3 key prefix matches are shuffled. If you useManifestFile, the order of the S3 object references in theManifestFileis shuffled. If you useAugmentedManifestFile, the order of the JSON lines in theAugmentedManifestFileis shuffled. The shuffling order is determined using theSeedvalue.For Pipe input mode, when
ShuffleConfigis specified shuffling is done at the start of every epoch. With large datasets, this ensures that the order of the training data is different for each epoch, and it helps reduce bias and possible overfitting. In a multi-node training job whenShuffleConfigis combined withS3DataDistributionTypeofShardedByS3Key, the data is shuffled across nodes so that the content sent to a particular node on the first epoch might be sent to a different node on the second epoch.- Source
Algorithm Specifies an algorithm that was used to create the model package. The algorithm must be either an algorithm resource in your SageMaker account or an algorithm in Amazon Web Services Marketplace that you are subscribed to.
- Source
Algorithm Specification A list of algorithms that were used to create a model package.
- Source
IpConfig A list of IP address ranges (CIDRs). Used to create an allow list of IP addresses for a private workforce. Workers will only be able to log in to their worker portal from an IP address within this range. By default, a workforce isn't restricted to specific IP addresses.
- Space
AppLifecycle Management Settings that are used to configure and manage the lifecycle of Amazon SageMaker Studio applications in a space.
- Space
Code Editor AppSettings The application settings for a Code Editor space.
- Space
Details The space's details.
- Space
Idle Settings Settings related to idle shutdown of Studio applications in a space.
- Space
Jupyter LabApp Settings The settings for the JupyterLab application within a space.
- Space
Settings A collection of space settings.
- Space
Settings Summary Specifies summary information about the space settings.
- Space
Sharing Settings A collection of space sharing settings.
- Space
Sharing Settings Summary Specifies summary information about the space sharing settings.
- Space
Storage Settings The storage settings for a space.
- Stairs
Defines the stairs traffic pattern for an Inference Recommender load test. This pattern type consists of multiple steps where the number of users increases at each step.
Specify either the stairs or phases traffic pattern.
- Stopping
Condition Specifies a limit to how long a job can run. When the job reaches the time limit, SageMaker ends the job. Use this API to cap costs.
To stop a training job, SageMaker sends the algorithm the
SIGTERMsignal, which delays job termination for 120 seconds. Algorithms can use this 120-second window to save the model artifacts, so the results of training are not lost.The training algorithms provided by SageMaker automatically save the intermediate results of a model training job when possible. This attempt to save artifacts is only a best effort case as model might not be in a state from which it can be saved. For example, if training has just started, the model might not be ready to save. When saved, this intermediate data is a valid model artifact. You can use it to create a model with
CreateModel.The Neural Topic Model (NTM) currently does not support saving intermediate model artifacts. When training NTMs, make sure that the maximum runtime is sufficient for the training job to complete.
- Studio
Lifecycle Config Details Details of the Amazon SageMaker AI Studio Lifecycle Configuration.
- Studio
WebPortal Settings Studio settings. If these settings are applied on a user level, they take priority over the settings applied on a domain level.
- Subscribed
Workteam Describes a work team of a vendor that does the labelling job.
- Suggestion
Query Specified in the GetSearchSuggestions request. Limits the property names that are included in the response.
- Tabular
JobConfig The collection of settings used by an AutoML job V2 for the tabular problem type.
- Tabular
Resolved Attributes The resolved attributes specific to the tabular problem type.
- Tag
A tag object that consists of a key and an optional value, used to manage metadata for SageMaker Amazon Web Services resources.
You can add tags to notebook instances, training jobs, hyperparameter tuning jobs, batch transform jobs, models, labeling jobs, work teams, endpoint configurations, and endpoints. For more information on adding tags to SageMaker resources, see AddTags.
For more information on adding metadata to your Amazon Web Services resources with tagging, see Tagging Amazon Web Services resources. For advice on best practices for managing Amazon Web Services resources with tagging, see Tagging Best Practices: Implement an Effective Amazon Web Services Resource Tagging Strategy.
- Target
Platform Contains information about a target platform that you want your model to run on, such as OS, architecture, and accelerators. It is an alternative of
TargetDevice.- Target
Tracking Scaling Policy Configuration A target tracking scaling policy. Includes support for predefined or customized metrics.
When using the PutScalingPolicy API, this parameter is required when you are creating a policy with the policy type
TargetTrackingScaling.- Tensor
Board AppSettings The TensorBoard app settings.
- Tensor
Board Output Config Configuration of storage locations for the Amazon SageMaker Debugger TensorBoard output data.
- Text
Classification JobConfig The collection of settings used by an AutoML job V2 for the text classification problem type.
- Text
Generation JobConfig The collection of settings used by an AutoML job V2 for the text generation problem type.
The text generation models that support fine-tuning in Autopilot are currently accessible exclusively in regions supported by Canvas. Refer to the documentation of Canvas for the full list of its supported Regions.
- Text
Generation Resolved Attributes The resolved attributes specific to the text generation problem type.
- Throughput
Config Used to set feature group throughput configuration. There are two modes:
ON_DEMANDandPROVISIONED. With on-demand mode, you are charged for data reads and writes that your application performs on your feature group. You do not need to specify read and write throughput because Feature Store accommodates your workloads as they ramp up and down. You can switch a feature group to on-demand only once in a 24 hour period. With provisioned throughput mode, you specify the read and write capacity per second that you expect your application to require, and you are billed based on those limits. Exceeding provisioned throughput will result in your requests being throttled.Note:
PROVISIONEDthroughput mode is supported only for feature groups that are offline-only, or use theStandardtier online store.- Throughput
Config Description Active throughput configuration of the feature group. There are two modes:
ON_DEMANDandPROVISIONED. With on-demand mode, you are charged for data reads and writes that your application performs on your feature group. You do not need to specify read and write throughput because Feature Store accommodates your workloads as they ramp up and down. You can switch a feature group to on-demand only once in a 24 hour period. With provisioned throughput mode, you specify the read and write capacity per second that you expect your application to require, and you are billed based on those limits. Exceeding provisioned throughput will result in your requests being throttled.Note:
PROVISIONEDthroughput mode is supported only for feature groups that are offline-only, or use theStandardtier online store.- Throughput
Config Update The new throughput configuration for the feature group. You can switch between on-demand and provisioned modes or update the read / write capacity of provisioned feature groups. You can switch a feature group to on-demand only once in a 24 hour period.
- Time
Series Config The collection of components that defines the time-series.
- Time
Series Forecasting JobConfig The collection of settings used by an AutoML job V2 for the time-series forecasting problem type.
- Time
Series Forecasting Settings Time series forecast settings for the SageMaker Canvas application.
- Time
Series Transformations Transformations allowed on the dataset. Supported transformations are
FillingandAggregation.Fillingspecifies how to add values to missing values in the dataset.Aggregationdefines how to aggregate data that does not align with forecast frequency.- Total
Hits Represents the total number of matching results and indicates how accurate that count is.
The
Valuefield provides the count, which may be exact or estimated. TheRelationfield indicates whether it's an exact figure or a lower bound. This helps understand the full scope of search results, especially when dealing with large result sets.- Tracking
Server Summary The summary of the tracking server to list.
- Traffic
Pattern Defines the traffic pattern of the load test.
- Traffic
Routing Config Defines the traffic routing strategy during an endpoint deployment to shift traffic from the old fleet to the new fleet.
- Training
Image Config The configuration to use an image from a private Docker registry for a training job.
- Training
Job Contains information about a training job.
- Training
JobDefinition Defines the input needed to run a training job using the algorithm.
- Training
JobStatus Counters The numbers of training jobs launched by a hyperparameter tuning job, categorized by status.
- Training
JobStep Metadata Metadata for a training job step.
- Training
JobSummary Provides summary information about a training job.
- Training
Plan Filter A filter to apply when listing or searching for training plans.
For more information about how to reserve GPU capacity for your SageMaker HyperPod clusters using Amazon SageMaker Training Plan, see
CreateTrainingPlan.- Training
Plan Offering Details about a training plan offering.
For more information about how to reserve GPU capacity for your SageMaker HyperPod clusters using Amazon SageMaker Training Plan, see
CreateTrainingPlan.- Training
Plan Summary Details of the training plan.
For more information about how to reserve GPU capacity for your SageMaker HyperPod clusters using Amazon SageMaker Training Plan, see
CreateTrainingPlan.- Training
Repository Auth Config An object containing authentication information for a private Docker registry.
- Training
Specification Defines how the algorithm is used for a training job.
- Transform
Data Source Describes the location of the channel data.
- Transform
Input Describes the input source of a transform job and the way the transform job consumes it.
- Transform
Job A batch transform job. For information about SageMaker batch transform, see Use Batch Transform.
- Transform
JobDefinition Defines the input needed to run a transform job using the inference specification specified in the algorithm.
- Transform
JobStep Metadata Metadata for a transform job step.
- Transform
JobSummary Provides a summary of a transform job. Multiple
TransformJobSummaryobjects are returned as a list after in response to a ListTransformJobs call.- Transform
Output Describes the results of a transform job.
- Transform
Resources Describes the resources, including ML instance types and ML instance count, to use for transform job.
- Transform
S3Data Source Describes the S3 data source.
- Trial
The properties of a trial as returned by the Search API.
- Trial
Component The properties of a trial component as returned by the Search API.
- Trial
Component Artifact Represents an input or output artifact of a trial component. You specify
TrialComponentArtifactas part of theInputArtifactsandOutputArtifactsparameters in the CreateTrialComponent request.Examples of input artifacts are datasets, algorithms, hyperparameters, source code, and instance types. Examples of output artifacts are metrics, snapshots, logs, and images.
- Trial
Component Metric Summary A summary of the metrics of a trial component.
- Trial
Component Simple Summary A short summary of a trial component.
- Trial
Component Source The Amazon Resource Name (ARN) and job type of the source of a trial component.
- Trial
Component Source Detail Detailed information about the source of a trial component. Either
ProcessingJoborTrainingJobis returned.- Trial
Component Status The status of the trial component.
- Trial
Component Summary A summary of the properties of a trial component. To get all the properties, call the DescribeTrialComponent API and provide the
TrialComponentName.- Trial
Source The source of the trial.
- Trial
Summary A summary of the properties of a trial. To get the complete set of properties, call the DescribeTrial API and provide the
TrialName.- TtlDuration
Time to live duration, where the record is hard deleted after the expiration time is reached;
ExpiresAt=EventTime+TtlDuration. For information on HardDelete, see the DeleteRecord API in the Amazon SageMaker API Reference guide.- Tuning
JobCompletion Criteria The job completion criteria.
- Tuning
JobStep Meta Data Metadata for a tuning step.
- UiConfig
Provided configuration information for the worker UI for a labeling job. Provide either
HumanTaskUiArnorUiTemplateS3Uri.For named entity recognition, 3D point cloud and video frame labeling jobs, use
HumanTaskUiArn.For all other Ground Truth built-in task types and custom task types, use
UiTemplateS3Urito specify the location of a worker task template in Amazon S3.- UiTemplate
The Liquid template for the worker user interface.
- UiTemplate
Info Container for user interface template information.
- Unified
Studio Settings The settings that apply to an Amazon SageMaker AI domain when you use it in Amazon SageMaker Unified Studio.
- Update
Cluster Software Instance Group Specification The configuration that describes specifications of the instance groups to update.
- Usd
Represents an amount of money in United States dollars.
- User
Context Information about the user who created or modified an experiment, trial, trial component, lineage group, project, or model card.
- User
Profile Details The user profile details.
- User
Settings A collection of settings that apply to users in a domain. These settings are specified when the
CreateUserProfileAPI is called, and asDefaultUserSettingswhen theCreateDomainAPI is called.SecurityGroupsis aggregated when specified in both calls. For all other settings inUserSettings, the values specified inCreateUserProfiletake precedence over those specified inCreateDomain.- Variant
Property Specifies a production variant property type for an Endpoint.
If you are updating an endpoint with the
RetainAllVariantPropertiesoption of UpdateEndpointInput set totrue, theVariantPropertyobjects listed in theExcludeRetainedVariantPropertiesparameter of UpdateEndpointInput override the existing variant properties of the endpoint.- Vector
Config Configuration for your vector collection type.
- Vertex
A lineage entity connected to the starting entity(ies).
- Visibility
Conditions The list of key-value pairs used to filter your search results. If a search result contains a key from your list, it is included in the final search response if the value associated with the key in the result matches the value you specified. If the value doesn't match, the result is excluded from the search response. Any resources that don't have a key from the list that you've provided will also be included in the search response.
- VpcConfig
Specifies an Amazon Virtual Private Cloud (VPC) that your SageMaker jobs, hosted models, and compute resources have access to. You can control access to and from your resources by configuring a VPC. For more information, see Give SageMaker Access to Resources in your Amazon VPC.
- Warm
Pool Status Status and billing information about the warm pool.
- Worker
Access Configuration Use this optional parameter to constrain access to an Amazon S3 resource based on the IP address using supported IAM global condition keys. The Amazon S3 resource is accessed in the worker portal using a Amazon S3 presigned URL.
- Workforce
A single private workforce, which is automatically created when you create your first private work team. You can create one private work force in each Amazon Web Services Region. By default, any workforce-related API operation used in a specific region will apply to the workforce created in that region. To learn how to create a private workforce, see Create a Private Workforce.
- Workforce
VpcConfig Request The VPC object you use to create or update a workforce.
- Workforce
VpcConfig Response A VpcConfig object that specifies the VPC that you want your workforce to connect to.
- Workspace
Settings The workspace settings for the SageMaker Canvas application.
- Workteam
Provides details about a labeling work team.
Enums§
- Action
Status - When writing a match expression against
ActionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Activation
State - When writing a match expression against
ActivationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Additional
S3Data Source Data Type - When writing a match expression against
AdditionalS3DataSourceDataType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Aggregation
Transformation Value - When writing a match expression against
AggregationTransformationValue, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Algorithm
Sort By - When writing a match expression against
AlgorithmSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Algorithm
Status - When writing a match expression against
AlgorithmStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - AppImage
Config Sort Key - When writing a match expression against
AppImageConfigSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - AppInstance
Type - When writing a match expression against
AppInstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - AppNetwork
Access Type - When writing a match expression against
AppNetworkAccessType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - AppSecurity
Group Management - When writing a match expression against
AppSecurityGroupManagement, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - AppSort
Key - When writing a match expression against
AppSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - AppStatus
- When writing a match expression against
AppStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - AppType
- When writing a match expression against
AppType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Artifact
Source IdType - When writing a match expression against
ArtifactSourceIdType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Assembly
Type - When writing a match expression against
AssemblyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Association
Edge Type - When writing a match expression against
AssociationEdgeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Async
Notification Topic Types - When writing a match expression against
AsyncNotificationTopicTypes, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Athena
Result Compression Type - When writing a match expression against
AthenaResultCompressionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Athena
Result Format - When writing a match expression against
AthenaResultFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auth
Mode - When writing a match expression against
AuthMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlAlgorithm - When writing a match expression against
AutoMlAlgorithm, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlChannel Type - When writing a match expression against
AutoMlChannelType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlJob Objective Type - When writing a match expression against
AutoMlJobObjectiveType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlJob Secondary Status - When writing a match expression against
AutoMlJobSecondaryStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlJob Status - When writing a match expression against
AutoMlJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlMetric Enum - When writing a match expression against
AutoMlMetricEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlMetric Extended Enum - When writing a match expression against
AutoMlMetricExtendedEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlMode - When writing a match expression against
AutoMlMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlProblem Type Config A collection of settings specific to the problem type used to configure an AutoML job V2. There must be one and only one config of the following type.
- Auto
MlProblem Type Config Name - When writing a match expression against
AutoMlProblemTypeConfigName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlProblem Type Resolved Attributes Stores resolved attributes specific to the problem type of an AutoML job V2.
- Auto
MlProcessing Unit - When writing a match expression against
AutoMlProcessingUnit, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlSort By - When writing a match expression against
AutoMlSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
MlSort Order - When writing a match expression against
AutoMlSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
Mls3 Data Type - When writing a match expression against
AutoMls3DataType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Auto
Mount Home Efs - When writing a match expression against
AutoMountHomeEfs, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Autotune
Mode - When writing a match expression against
AutotuneMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - AwsManaged
Human Loop Request Source - When writing a match expression against
AwsManagedHumanLoopRequestSource, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Batch
Delete Cluster Nodes Error Code - When writing a match expression against
BatchDeleteClusterNodesErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Batch
Strategy - When writing a match expression against
BatchStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Boolean
Operator - When writing a match expression against
BooleanOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Candidate
Sort By - When writing a match expression against
CandidateSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Candidate
Status - When writing a match expression against
CandidateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Candidate
Step Type - When writing a match expression against
CandidateStepType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Capacity
Reservation Preference - When writing a match expression against
CapacityReservationPreference, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Capacity
Size Type - When writing a match expression against
CapacitySizeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Capture
Mode - When writing a match expression against
CaptureMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Capture
Status - When writing a match expression against
CaptureStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Clarify
Feature Type - When writing a match expression against
ClarifyFeatureType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Clarify
Text Granularity - When writing a match expression against
ClarifyTextGranularity, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Clarify
Text Language - When writing a match expression against
ClarifyTextLanguage, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Cluster
Instance Status - When writing a match expression against
ClusterInstanceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Cluster
Instance Storage Config Defines the configuration for attaching additional storage to the instances in the SageMaker HyperPod cluster instance group. To learn more, see SageMaker HyperPod release notes: June 20, 2024.
- Cluster
Instance Type - When writing a match expression against
ClusterInstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Cluster
Node Recovery - When writing a match expression against
ClusterNodeRecovery, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Cluster
Sort By - When writing a match expression against
ClusterSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Cluster
Status - When writing a match expression against
ClusterStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Code
Repository Sort By - When writing a match expression against
CodeRepositorySortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Code
Repository Sort Order - When writing a match expression against
CodeRepositorySortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Collection
Config Configuration for your collection.
- Collection
Type - When writing a match expression against
CollectionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Compilation
JobStatus - When writing a match expression against
CompilationJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Complete
OnConvergence - When writing a match expression against
CompleteOnConvergence, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Compression
Type - When writing a match expression against
CompressionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Condition
Outcome - When writing a match expression against
ConditionOutcome, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Container
Mode - When writing a match expression against
ContainerMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Content
Classifier - When writing a match expression against
ContentClassifier, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Cross
Account Filter Option - When writing a match expression against
CrossAccountFilterOption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Custom
File System A file system, created by you, that you assign to a user profile or space for an Amazon SageMaker AI Domain. Permitted users can access this file system in Amazon SageMaker AI Studio.
- Custom
File System Config The settings for assigning a custom file system to a user profile or space for an Amazon SageMaker AI Domain. Permitted users can access this file system in Amazon SageMaker AI Studio.
- Data
Distribution Type - When writing a match expression against
DataDistributionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Data
Source Name - When writing a match expression against
DataSourceName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Deep
Health Check Type - When writing a match expression against
DeepHealthCheckType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Detailed
Algorithm Status - When writing a match expression against
DetailedAlgorithmStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Detailed
Model Package Status - When writing a match expression against
DetailedModelPackageStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Device
Deployment Status - When writing a match expression against
DeviceDeploymentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Device
Subset Type - When writing a match expression against
DeviceSubsetType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Direct
Internet Access - When writing a match expression against
DirectInternetAccess, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Direction
- When writing a match expression against
Direction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Domain
Status - When writing a match expression against
DomainStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Edge
Packaging JobStatus - When writing a match expression against
EdgePackagingJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Edge
Preset Deployment Status - When writing a match expression against
EdgePresetDeploymentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Edge
Preset Deployment Type - When writing a match expression against
EdgePresetDeploymentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Enabled
OrDisabled - When writing a match expression against
EnabledOrDisabled, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Endpoint
Config Sort Key - When writing a match expression against
EndpointConfigSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Endpoint
Sort Key - When writing a match expression against
EndpointSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Endpoint
Status - When writing a match expression against
EndpointStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Execution
Role Identity Config - When writing a match expression against
ExecutionRoleIdentityConfig, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Execution
Status - When writing a match expression against
ExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Failure
Handling Policy - When writing a match expression against
FailureHandlingPolicy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Fair
Share - When writing a match expression against
FairShare, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Feature
Group Sort By - When writing a match expression against
FeatureGroupSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Feature
Group Sort Order - When writing a match expression against
FeatureGroupSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Feature
Group Status - When writing a match expression against
FeatureGroupStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Feature
Status - When writing a match expression against
FeatureStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Feature
Type - When writing a match expression against
FeatureType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - File
System Access Mode - When writing a match expression against
FileSystemAccessMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - File
System Type - When writing a match expression against
FileSystemType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Filling
Type - When writing a match expression against
FillingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Flat
Invocations - When writing a match expression against
FlatInvocations, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Flow
Definition Status - When writing a match expression against
FlowDefinitionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Framework
- When writing a match expression against
Framework, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - HubContent
Sort By - When writing a match expression against
HubContentSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - HubContent
Status - When writing a match expression against
HubContentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - HubContent
Support Status - When writing a match expression against
HubContentSupportStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - HubContent
Type - When writing a match expression against
HubContentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - HubSort
By - When writing a match expression against
HubSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - HubStatus
- When writing a match expression against
HubStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Human
Task UiStatus - When writing a match expression against
HumanTaskUiStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Hyper
Parameter Scaling Type - When writing a match expression against
HyperParameterScalingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Hyper
Parameter Tuning Allocation Strategy - When writing a match expression against
HyperParameterTuningAllocationStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Hyper
Parameter Tuning JobObjective Type - When writing a match expression against
HyperParameterTuningJobObjectiveType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Hyper
Parameter Tuning JobSort ByOptions - When writing a match expression against
HyperParameterTuningJobSortByOptions, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Hyper
Parameter Tuning JobStatus - When writing a match expression against
HyperParameterTuningJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Hyper
Parameter Tuning JobStrategy Type - When writing a match expression against
HyperParameterTuningJobStrategyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Hyper
Parameter Tuning JobWarm Start Type - When writing a match expression against
HyperParameterTuningJobWarmStartType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Image
Sort By - When writing a match expression against
ImageSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Image
Sort Order - When writing a match expression against
ImageSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Image
Status - When writing a match expression against
ImageStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Image
Version Sort By - When writing a match expression against
ImageVersionSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Image
Version Sort Order - When writing a match expression against
ImageVersionSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Image
Version Status - When writing a match expression against
ImageVersionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Inference
Component Capacity Size Type - When writing a match expression against
InferenceComponentCapacitySizeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Inference
Component Sort Key - When writing a match expression against
InferenceComponentSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Inference
Component Status - When writing a match expression against
InferenceComponentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Inference
Execution Mode - When writing a match expression against
InferenceExecutionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Inference
Experiment Status - When writing a match expression against
InferenceExperimentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Inference
Experiment Stop Desired State - When writing a match expression against
InferenceExperimentStopDesiredState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Inference
Experiment Type - When writing a match expression against
InferenceExperimentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Input
Mode - When writing a match expression against
InputMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Instance
Group Status - When writing a match expression against
InstanceGroupStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Instance
Type - When writing a match expression against
InstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - IsTracking
Server Active - When writing a match expression against
IsTrackingServerActive, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - JobType
- When writing a match expression against
JobType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Join
Source - When writing a match expression against
JoinSource, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Labeling
JobStatus - When writing a match expression against
LabelingJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Last
Update Status Value - When writing a match expression against
LastUpdateStatusValue, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Lifecycle
Management - When writing a match expression against
LifecycleManagement, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Lineage
Type - When writing a match expression against
LineageType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - List
Compilation Jobs Sort By - When writing a match expression against
ListCompilationJobsSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - List
Device Fleets Sort By - When writing a match expression against
ListDeviceFleetsSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - List
Edge Deployment Plans Sort By - When writing a match expression against
ListEdgeDeploymentPlansSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - List
Edge Packaging Jobs Sort By - When writing a match expression against
ListEdgePackagingJobsSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - List
Inference Recommendations Jobs Sort By - When writing a match expression against
ListInferenceRecommendationsJobsSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - List
Labeling Jobs ForWorkteam Sort ByOptions - When writing a match expression against
ListLabelingJobsForWorkteamSortByOptions, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - List
Optimization Jobs Sort By - When writing a match expression against
ListOptimizationJobsSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - List
Workforces Sort ByOptions - When writing a match expression against
ListWorkforcesSortByOptions, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - List
Workteams Sort ByOptions - When writing a match expression against
ListWorkteamsSortByOptions, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Managed
Instance Scaling Status - When writing a match expression against
ManagedInstanceScalingStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Metric
SetSource - When writing a match expression against
MetricSetSource, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Metric
Specification An object containing information about a metric.
- MlTools
- When writing a match expression against
MlTools, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Approval Status - When writing a match expression against
ModelApprovalStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Cache Setting - When writing a match expression against
ModelCacheSetting, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Card Export JobSort By - When writing a match expression against
ModelCardExportJobSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Card Export JobSort Order - When writing a match expression against
ModelCardExportJobSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Card Export JobStatus - When writing a match expression against
ModelCardExportJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Card Processing Status - When writing a match expression against
ModelCardProcessingStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Card Sort By - When writing a match expression against
ModelCardSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Card Sort Order - When writing a match expression against
ModelCardSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Card Status - When writing a match expression against
ModelCardStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Card Version Sort By - When writing a match expression against
ModelCardVersionSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Compression Type - When writing a match expression against
ModelCompressionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Infrastructure Type - When writing a match expression against
ModelInfrastructureType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Metadata Filter Type - When writing a match expression against
ModelMetadataFilterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Package Group Sort By - When writing a match expression against
ModelPackageGroupSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Package Group Status - When writing a match expression against
ModelPackageGroupStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Package Sort By - When writing a match expression against
ModelPackageSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Package Status - When writing a match expression against
ModelPackageStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Package Type - When writing a match expression against
ModelPackageType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Sort Key - When writing a match expression against
ModelSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Variant Action - When writing a match expression against
ModelVariantAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Model
Variant Status - When writing a match expression against
ModelVariantStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Monitoring
Alert History Sort Key - When writing a match expression against
MonitoringAlertHistorySortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Monitoring
Alert Status - When writing a match expression against
MonitoringAlertStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Monitoring
Execution Sort Key - When writing a match expression against
MonitoringExecutionSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Monitoring
JobDefinition Sort Key - When writing a match expression against
MonitoringJobDefinitionSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Monitoring
Problem Type - When writing a match expression against
MonitoringProblemType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Monitoring
Schedule Sort Key - When writing a match expression against
MonitoringScheduleSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Monitoring
Type - When writing a match expression against
MonitoringType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Node
Unavailability Type - When writing a match expression against
NodeUnavailabilityType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Notebook
Instance Accelerator Type - When writing a match expression against
NotebookInstanceAcceleratorType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Notebook
Instance Lifecycle Config Sort Key - When writing a match expression against
NotebookInstanceLifecycleConfigSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Notebook
Instance Lifecycle Config Sort Order - When writing a match expression against
NotebookInstanceLifecycleConfigSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Notebook
Instance Sort Key - When writing a match expression against
NotebookInstanceSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Notebook
Instance Sort Order - When writing a match expression against
NotebookInstanceSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Notebook
Instance Status - When writing a match expression against
NotebookInstanceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Notebook
Output Option - When writing a match expression against
NotebookOutputOption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Objective
Status - When writing a match expression against
ObjectiveStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Offline
Store Status Value - When writing a match expression against
OfflineStoreStatusValue, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Operator
- When writing a match expression against
Operator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Optimization
Config Settings for an optimization technique that you apply with a model optimization job.
- Optimization
JobDeployment Instance Type - When writing a match expression against
OptimizationJobDeploymentInstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Optimization
JobStatus - When writing a match expression against
OptimizationJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Order
Key - When writing a match expression against
OrderKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Output
Compression Type - When writing a match expression against
OutputCompressionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Parameter
Type - 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. - Partner
AppAuth Type - When writing a match expression against
PartnerAppAuthType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Partner
AppStatus - When writing a match expression against
PartnerAppStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Partner
AppType - When writing a match expression against
PartnerAppType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Pipeline
Execution Status - When writing a match expression against
PipelineExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Pipeline
Status - When writing a match expression against
PipelineStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Preempt
Team Tasks - When writing a match expression against
PreemptTeamTasks, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Problem
Type - When writing a match expression against
ProblemType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Processing
Instance Type - When writing a match expression against
ProcessingInstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Processing
JobStatus - When writing a match expression against
ProcessingJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Processing
S3Compression Type - When writing a match expression against
ProcessingS3CompressionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Processing
S3Data Distribution Type - When writing a match expression against
ProcessingS3DataDistributionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Processing
S3Data Type - When writing a match expression against
ProcessingS3DataType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Processing
S3Input Mode - When writing a match expression against
ProcessingS3InputMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Processing
S3Upload Mode - When writing a match expression against
ProcessingS3UploadMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Processor
- When writing a match expression against
Processor, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Production
Variant Accelerator Type - When writing a match expression against
ProductionVariantAcceleratorType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Production
Variant Inference AmiVersion - When writing a match expression against
ProductionVariantInferenceAmiVersion, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Production
Variant Instance Type - When writing a match expression against
ProductionVariantInstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Profiling
Status - When writing a match expression against
ProfilingStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Project
Sort By - When writing a match expression against
ProjectSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Project
Sort Order - When writing a match expression against
ProjectSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Project
Status - When writing a match expression against
ProjectStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - RStudio
Server ProAccess Status - When writing a match expression against
RStudioServerProAccessStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - RStudio
Server ProUser Group - When writing a match expression against
RStudioServerProUserGroup, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Recommendation
JobStatus - When writing a match expression against
RecommendationJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Recommendation
JobSupported Endpoint Type - When writing a match expression against
RecommendationJobSupportedEndpointType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Recommendation
JobType - When writing a match expression against
RecommendationJobType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Recommendation
Status - When writing a match expression against
RecommendationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Recommendation
Step Type - When writing a match expression against
RecommendationStepType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Record
Wrapper - When writing a match expression against
RecordWrapper, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Redshift
Result Compression Type - When writing a match expression against
RedshiftResultCompressionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Redshift
Result Format - When writing a match expression against
RedshiftResultFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Relation
- When writing a match expression against
Relation, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Repository
Access Mode - When writing a match expression against
RepositoryAccessMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Reserved
Capacity Instance Type - When writing a match expression against
ReservedCapacityInstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Reserved
Capacity Status - When writing a match expression against
ReservedCapacityStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Resource
Catalog Sort By - When writing a match expression against
ResourceCatalogSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Resource
Catalog Sort Order - When writing a match expression against
ResourceCatalogSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Resource
Sharing Strategy - When writing a match expression against
ResourceSharingStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Resource
Type - 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. - Retention
Type - When writing a match expression against
RetentionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Root
Access - When writing a match expression against
RootAccess, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Routing
Strategy - When writing a match expression against
RoutingStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Rule
Evaluation Status - When writing a match expression against
RuleEvaluationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - S3Data
Distribution - When writing a match expression against
S3DataDistribution, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - S3Data
Type - When writing a match expression against
S3DataType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - S3Model
Data Type - When writing a match expression against
S3ModelDataType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sage
Maker Image Name - When writing a match expression against
SageMakerImageName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sage
Maker Resource Name - When writing a match expression against
SageMakerResourceName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sagemaker
Servicecatalog Status - When writing a match expression against
SagemakerServicecatalogStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Scaling
Policy An object containing a recommended scaling policy.
- Schedule
Status - When writing a match expression against
ScheduleStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Scheduler
Resource Status - When writing a match expression against
SchedulerResourceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Search
Sort Order - When writing a match expression against
SearchSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Secondary
Status - When writing a match expression against
SecondaryStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sharing
Type - When writing a match expression against
SharingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Skip
Model Validation - When writing a match expression against
SkipModelValidation, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Actions By - When writing a match expression against
SortActionsBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Artifacts By - When writing a match expression against
SortArtifactsBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Associations By - When writing a match expression against
SortAssociationsBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - SortBy
- When writing a match expression against
SortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Cluster Scheduler Config By - When writing a match expression against
SortClusterSchedulerConfigBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Contexts By - When writing a match expression against
SortContextsBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Experiments By - When writing a match expression against
SortExperimentsBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Inference Experiments By - When writing a match expression against
SortInferenceExperimentsBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Lineage Groups By - When writing a match expression against
SortLineageGroupsBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Order - 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. - Sort
Pipeline Executions By - When writing a match expression against
SortPipelineExecutionsBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Pipelines By - When writing a match expression against
SortPipelinesBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Quota By - When writing a match expression against
SortQuotaBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Tracking Server By - When writing a match expression against
SortTrackingServerBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Trial Components By - When writing a match expression against
SortTrialComponentsBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Sort
Trials By - When writing a match expression against
SortTrialsBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Space
Sort Key - When writing a match expression against
SpaceSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Space
Status - When writing a match expression against
SpaceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Split
Type - When writing a match expression against
SplitType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Stage
Status - When writing a match expression against
StageStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Statistic
- When writing a match expression against
Statistic, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Step
Status - When writing a match expression against
StepStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Storage
Type - When writing a match expression against
StorageType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Studio
Lifecycle Config AppType - When writing a match expression against
StudioLifecycleConfigAppType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Studio
Lifecycle Config Sort Key - When writing a match expression against
StudioLifecycleConfigSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Studio
WebPortal - When writing a match expression against
StudioWebPortal, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Table
Format - When writing a match expression against
TableFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - TagPropagation
- When writing a match expression against
TagPropagation, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Target
Device - When writing a match expression against
TargetDevice, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Target
Platform Accelerator - When writing a match expression against
TargetPlatformAccelerator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Target
Platform Arch - When writing a match expression against
TargetPlatformArch, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Target
Platform Os - When writing a match expression against
TargetPlatformOs, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Throughput
Mode - When writing a match expression against
ThroughputMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Tracking
Server Maintenance Status - When writing a match expression against
TrackingServerMaintenanceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Tracking
Server Size - When writing a match expression against
TrackingServerSize, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Tracking
Server Status - When writing a match expression against
TrackingServerStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Traffic
Routing Config Type - When writing a match expression against
TrafficRoutingConfigType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Traffic
Type - When writing a match expression against
TrafficType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Training
Input Mode - When writing a match expression against
TrainingInputMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Training
Instance Type - When writing a match expression against
TrainingInstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Training
JobEarly Stopping Type - When writing a match expression against
TrainingJobEarlyStoppingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Training
JobSort ByOptions - When writing a match expression against
TrainingJobSortByOptions, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Training
JobStatus - When writing a match expression against
TrainingJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Training
Plan Filter Name - When writing a match expression against
TrainingPlanFilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Training
Plan Sort By - When writing a match expression against
TrainingPlanSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Training
Plan Sort Order - When writing a match expression against
TrainingPlanSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Training
Plan Status - When writing a match expression against
TrainingPlanStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Training
Repository Access Mode - When writing a match expression against
TrainingRepositoryAccessMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Transform
Instance Type - When writing a match expression against
TransformInstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Transform
JobStatus - When writing a match expression against
TransformJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Trial
Component Parameter Value The value of a hyperparameter. Only one of
NumberValueorStringValuecan be specified.This object is specified in the CreateTrialComponent request.
- Trial
Component Primary Status - When writing a match expression against
TrialComponentPrimaryStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - TtlDuration
Unit - When writing a match expression against
TtlDurationUnit, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - User
Profile Sort Key - When writing a match expression against
UserProfileSortKey, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - User
Profile Status - When writing a match expression against
UserProfileStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Variant
Property Type - When writing a match expression against
VariantPropertyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Variant
Status - When writing a match expression against
VariantStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Vendor
Guidance - When writing a match expression against
VendorGuidance, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Warm
Pool Resource Status - When writing a match expression against
WarmPoolResourceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature. - Workforce
Status - When writing a match expression against
WorkforceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.